]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * Copyright (C) 1999-2000 Harri Porten (porten@kde.org) | |
3 | * Copyright (C) 2001 Peter Kelly (pmk@post.com) | |
4 | * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved. | |
5 | * Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca) | |
6 | * Copyright (C) 2007 Maks Orlovich | |
7 | * Copyright (C) 2007 Eric Seidel <eric@webkit.org> | |
8 | * | |
9 | * This library is free software; you can redistribute it and/or | |
10 | * modify it under the terms of the GNU Library General Public | |
11 | * License as published by the Free Software Foundation; either | |
12 | * version 2 of the License, or (at your option) any later version. | |
13 | * | |
14 | * This library is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
17 | * Library General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU Library General Public License | |
20 | * along with this library; see the file COPYING.LIB. If not, write to | |
21 | * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | |
22 | * Boston, MA 02110-1301, USA. | |
23 | * | |
24 | */ | |
25 | ||
26 | #ifndef NODES_H_ | |
27 | #define NODES_H_ | |
28 | ||
29 | #include "internal.h" | |
30 | #include "regexp.h" | |
31 | #include "SymbolTable.h" | |
32 | #include <wtf/ListRefPtr.h> | |
33 | #include <wtf/MathExtras.h> | |
34 | #include <wtf/OwnPtr.h> | |
35 | #include <wtf/Vector.h> | |
36 | ||
37 | #if PLATFORM(X86) && COMPILER(GCC) | |
38 | #define KJS_FAST_CALL __attribute__((regparm(3))) | |
39 | #else | |
40 | #define KJS_FAST_CALL | |
41 | #endif | |
42 | ||
43 | namespace KJS { | |
44 | ||
45 | class ConstDeclNode; | |
46 | class FuncDeclNode; | |
47 | class Node; | |
48 | class PropertyListNode; | |
49 | class SourceStream; | |
50 | ||
51 | enum Operator { | |
52 | OpEqual, | |
53 | OpPlusEq, | |
54 | OpMinusEq, | |
55 | OpMultEq, | |
56 | OpDivEq, | |
57 | OpPlusPlus, | |
58 | OpMinusMinus, | |
59 | OpAndEq, | |
60 | OpXOrEq, | |
61 | OpOrEq, | |
62 | OpModEq, | |
63 | OpLShift, | |
64 | OpRShift, | |
65 | OpURShift, | |
66 | }; | |
67 | ||
68 | enum Precedence { | |
69 | PrecPrimary, | |
70 | PrecMember, | |
71 | PrecCall, | |
72 | PrecLeftHandSide, | |
73 | PrecPostfix, | |
74 | PrecUnary, | |
75 | PrecMultiplicitave, | |
76 | PrecAdditive, | |
77 | PrecShift, | |
78 | PrecRelational, | |
79 | PrecEquality, | |
80 | PrecBitwiseAnd, | |
81 | PrecBitwiseXor, | |
82 | PrecBitwiseOr, | |
83 | PrecLogicalAnd, | |
84 | PrecLogicalOr, | |
85 | PrecConditional, | |
86 | PrecAssignment, | |
87 | PrecExpression | |
88 | }; | |
89 | ||
90 | struct DeclarationStacks { | |
91 | typedef Vector<Node*, 16> NodeStack; | |
92 | enum { IsConstant = 1, HasInitializer = 2 } VarAttrs; | |
93 | typedef Vector<std::pair<Identifier, unsigned>, 16> VarStack; | |
94 | typedef Vector<FuncDeclNode*, 16> FunctionStack; | |
95 | ||
96 | DeclarationStacks(ExecState* e, NodeStack& n, VarStack& v, FunctionStack& f) | |
97 | : exec(e) | |
98 | , nodeStack(n) | |
99 | , varStack(v) | |
100 | , functionStack(f) | |
101 | { | |
102 | } | |
103 | ||
104 | ExecState* exec; | |
105 | NodeStack& nodeStack; | |
106 | VarStack& varStack; | |
107 | FunctionStack& functionStack; | |
108 | }; | |
109 | ||
110 | class ParserRefCounted : Noncopyable { | |
111 | protected: | |
112 | ParserRefCounted() KJS_FAST_CALL; | |
113 | ParserRefCounted(PlacementNewAdoptType) KJS_FAST_CALL | |
114 | { | |
115 | } | |
116 | ||
117 | public: | |
118 | void ref() KJS_FAST_CALL; | |
119 | void deref() KJS_FAST_CALL; | |
120 | unsigned refcount() KJS_FAST_CALL; | |
121 | ||
122 | static void deleteNewObjects() KJS_FAST_CALL; | |
123 | ||
124 | virtual ~ParserRefCounted(); | |
125 | }; | |
126 | ||
127 | class Node : public ParserRefCounted { | |
128 | public: | |
129 | typedef DeclarationStacks::NodeStack NodeStack; | |
130 | typedef DeclarationStacks::VarStack VarStack; | |
131 | typedef DeclarationStacks::FunctionStack FunctionStack; | |
132 | ||
133 | Node() KJS_FAST_CALL; | |
134 | Node(PlacementNewAdoptType placementAdopt) KJS_FAST_CALL | |
135 | : ParserRefCounted(placementAdopt) | |
136 | { | |
137 | } | |
138 | ||
139 | UString toString() const KJS_FAST_CALL; | |
140 | int lineNo() const KJS_FAST_CALL { return m_line; } | |
141 | ||
142 | // Serialization. | |
143 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL = 0; | |
144 | virtual Precedence precedence() const = 0; | |
145 | virtual bool needsParensIfLeftmost() const { return false; } | |
146 | ||
147 | // Used for iterative, depth-first traversal of the node tree. Does not cross function call boundaries. | |
148 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL { } | |
149 | ||
150 | protected: | |
151 | JSValue* setInterruptedCompletion(ExecState*); | |
152 | Node(JSType) KJS_FAST_CALL; // used by ExpressionNode | |
153 | ||
154 | // for use in execute() | |
155 | JSValue* setErrorCompletion(ExecState*, ErrorType, const char* msg) KJS_FAST_CALL; | |
156 | JSValue* setErrorCompletion(ExecState*, ErrorType, const char* msg, const Identifier&) KJS_FAST_CALL; | |
157 | ||
158 | // for use in evaluate() | |
159 | JSValue* throwError(ExecState*, ErrorType, const char* msg) KJS_FAST_CALL; | |
160 | JSValue* throwError(ExecState*, ErrorType, const char* msg, const char*) KJS_FAST_CALL; | |
161 | JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*) KJS_FAST_CALL; | |
162 | JSValue* throwError(ExecState*, ErrorType, const char* msg, const Identifier&) KJS_FAST_CALL; | |
163 | JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, const Identifier&) KJS_FAST_CALL; | |
164 | JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*, Node*) KJS_FAST_CALL; | |
165 | JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*, const Identifier&) KJS_FAST_CALL; | |
166 | ||
167 | JSValue* throwUndefinedVariableError(ExecState*, const Identifier&) KJS_FAST_CALL; | |
168 | ||
169 | void handleException(ExecState*) KJS_FAST_CALL; | |
170 | void handleException(ExecState*, JSValue*) KJS_FAST_CALL; | |
171 | ||
172 | // for use in execute() | |
173 | JSValue* rethrowException(ExecState*) KJS_FAST_CALL; | |
174 | ||
175 | int m_line : 28; | |
176 | unsigned m_expectedReturnType : 3; // JSType | |
177 | }; | |
178 | ||
179 | class ExpressionNode : public Node { | |
180 | public: | |
181 | ExpressionNode() KJS_FAST_CALL : Node() {} | |
182 | ExpressionNode(JSType expectedReturn) KJS_FAST_CALL | |
183 | : Node(expectedReturn) | |
184 | { | |
185 | } | |
186 | ||
187 | // Special constructor for cases where we overwrite an object in place. | |
188 | ExpressionNode(PlacementNewAdoptType) KJS_FAST_CALL | |
189 | : Node(PlacementNewAdopt) | |
190 | { | |
191 | } | |
192 | ||
193 | virtual bool isNumber() const KJS_FAST_CALL { return false; } | |
194 | virtual bool isLocation() const KJS_FAST_CALL { return false; } | |
195 | virtual bool isResolveNode() const KJS_FAST_CALL { return false; } | |
196 | virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return false; } | |
197 | virtual bool isDotAccessorNode() const KJS_FAST_CALL { return false; } | |
198 | ||
199 | JSType expectedReturnType() const KJS_FAST_CALL { return static_cast<JSType>(m_expectedReturnType); } | |
200 | ||
201 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL = 0; | |
202 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
203 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
204 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
205 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
206 | ||
207 | // Used to optimize those nodes that do extra work when returning a result, even if the result has no semantic relevance | |
208 | virtual void optimizeForUnnecessaryResult() { } | |
209 | }; | |
210 | ||
211 | class StatementNode : public Node { | |
212 | public: | |
213 | StatementNode() KJS_FAST_CALL; | |
214 | void setLoc(int line0, int line1) KJS_FAST_CALL; | |
215 | int firstLine() const KJS_FAST_CALL { return lineNo(); } | |
216 | int lastLine() const KJS_FAST_CALL { return m_lastLine; } | |
217 | virtual JSValue* execute(ExecState *exec) KJS_FAST_CALL = 0; | |
218 | void pushLabel(const Identifier& ident) KJS_FAST_CALL { m_labelStack.push(ident); } | |
219 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
220 | virtual bool isEmptyStatement() const KJS_FAST_CALL { return false; } | |
221 | ||
222 | protected: | |
223 | LabelStack m_labelStack; | |
224 | ||
225 | private: | |
226 | int m_lastLine; | |
227 | }; | |
228 | ||
229 | class NullNode : public ExpressionNode { | |
230 | public: | |
231 | NullNode() KJS_FAST_CALL : ExpressionNode(NullType) {} | |
232 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
233 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
234 | virtual Precedence precedence() const { return PrecPrimary; } | |
235 | }; | |
236 | ||
237 | class FalseNode : public ExpressionNode { | |
238 | public: | |
239 | FalseNode() KJS_FAST_CALL | |
240 | : ExpressionNode(BooleanType) | |
241 | { | |
242 | } | |
243 | ||
244 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
245 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL { return false; } | |
246 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
247 | virtual Precedence precedence() const { return PrecPrimary; } | |
248 | }; | |
249 | ||
250 | class TrueNode : public ExpressionNode { | |
251 | public: | |
252 | TrueNode() KJS_FAST_CALL | |
253 | : ExpressionNode(BooleanType) | |
254 | { | |
255 | } | |
256 | ||
257 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
258 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL { return true; } | |
259 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
260 | virtual Precedence precedence() const { return PrecPrimary; } | |
261 | }; | |
262 | ||
263 | class PlaceholderTrueNode : public TrueNode { | |
264 | public: | |
265 | // Like TrueNode, but does not serialize as "true". | |
266 | PlaceholderTrueNode() KJS_FAST_CALL | |
267 | : TrueNode() | |
268 | { | |
269 | } | |
270 | ||
271 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
272 | }; | |
273 | ||
274 | class NumberNode : public ExpressionNode { | |
275 | public: | |
276 | NumberNode(double v) KJS_FAST_CALL | |
277 | : ExpressionNode(NumberType) | |
278 | , m_double(v) | |
279 | { | |
280 | } | |
281 | ||
282 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
283 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
284 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
285 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
286 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
287 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
288 | virtual Precedence precedence() const { return signbit(m_double) ? PrecUnary : PrecPrimary; } | |
289 | ||
290 | virtual bool isNumber() const KJS_FAST_CALL { return true; } | |
291 | double value() const KJS_FAST_CALL { return m_double; } | |
292 | virtual void setValue(double d) KJS_FAST_CALL { m_double = d; } | |
293 | ||
294 | protected: | |
295 | double m_double; | |
296 | }; | |
297 | ||
298 | class ImmediateNumberNode : public NumberNode { | |
299 | public: | |
300 | ImmediateNumberNode(JSValue* v, double d) KJS_FAST_CALL | |
301 | : NumberNode(d) | |
302 | , m_value(v) | |
303 | { | |
304 | ASSERT(v == JSImmediate::from(d)); | |
305 | } | |
306 | ||
307 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
308 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
309 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
310 | ||
311 | virtual void setValue(double d) KJS_FAST_CALL { m_double = d; m_value = JSImmediate::from(d); ASSERT(m_value); } | |
312 | ||
313 | private: | |
314 | JSValue* m_value; // This is never a JSCell, only JSImmediate, thus no ProtectedPtr | |
315 | }; | |
316 | ||
317 | class StringNode : public ExpressionNode { | |
318 | public: | |
319 | StringNode(const UString* v) KJS_FAST_CALL | |
320 | : ExpressionNode(StringType) | |
321 | , m_value(*v) | |
322 | { | |
323 | } | |
324 | ||
325 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
326 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
327 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
328 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
329 | virtual Precedence precedence() const { return PrecPrimary; } | |
330 | ||
331 | private: | |
332 | UString m_value; | |
333 | }; | |
334 | ||
335 | class RegExpNode : public ExpressionNode { | |
336 | public: | |
337 | RegExpNode(const UString& pattern, const UString& flags) KJS_FAST_CALL | |
338 | : m_regExp(new RegExp(pattern, flags)) | |
339 | { | |
340 | } | |
341 | ||
342 | JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
343 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
344 | virtual Precedence precedence() const { return PrecPrimary; } | |
345 | ||
346 | private: | |
347 | RefPtr<RegExp> m_regExp; | |
348 | }; | |
349 | ||
350 | class ThisNode : public ExpressionNode { | |
351 | public: | |
352 | ThisNode() KJS_FAST_CALL | |
353 | { | |
354 | } | |
355 | ||
356 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
357 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
358 | virtual Precedence precedence() const { return PrecPrimary; } | |
359 | }; | |
360 | ||
361 | class ResolveNode : public ExpressionNode { | |
362 | public: | |
363 | ResolveNode(const Identifier& ident) KJS_FAST_CALL | |
364 | : m_ident(ident) | |
365 | { | |
366 | } | |
367 | ||
368 | // Special constructor for cases where we overwrite an object in place. | |
369 | ResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
370 | : ExpressionNode(PlacementNewAdopt) | |
371 | , m_ident(PlacementNewAdopt) | |
372 | { | |
373 | } | |
374 | ||
375 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
376 | ||
377 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
378 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
379 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
380 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
381 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
382 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
383 | virtual Precedence precedence() const { return PrecPrimary; } | |
384 | ||
385 | virtual bool isLocation() const KJS_FAST_CALL { return true; } | |
386 | virtual bool isResolveNode() const KJS_FAST_CALL { return true; } | |
387 | const Identifier& identifier() const KJS_FAST_CALL { return m_ident; } | |
388 | ||
389 | protected: | |
390 | ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*); | |
391 | Identifier m_ident; | |
392 | size_t m_index; // Used by LocalVarAccessNode. | |
393 | }; | |
394 | ||
395 | class LocalVarAccessNode : public ResolveNode { | |
396 | public: | |
397 | // Overwrites a ResolveNode in place. | |
398 | LocalVarAccessNode(size_t i) KJS_FAST_CALL | |
399 | : ResolveNode(PlacementNewAdopt) | |
400 | { | |
401 | ASSERT(i != missingSymbolMarker()); | |
402 | m_index = i; | |
403 | } | |
404 | ||
405 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
406 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
407 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
408 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
409 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
410 | ||
411 | private: | |
412 | ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*); | |
413 | }; | |
414 | ||
415 | class ElementNode : public Node { | |
416 | public: | |
417 | ElementNode(int elision, ExpressionNode* node) KJS_FAST_CALL | |
418 | : m_elision(elision) | |
419 | , m_node(node) | |
420 | { | |
421 | } | |
422 | ||
423 | ElementNode(ElementNode* l, int elision, ExpressionNode* node) KJS_FAST_CALL | |
424 | : m_elision(elision) | |
425 | , m_node(node) | |
426 | { | |
427 | l->m_next = this; | |
428 | } | |
429 | ||
430 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
431 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
432 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
433 | ||
434 | PassRefPtr<ElementNode> releaseNext() KJS_FAST_CALL { return m_next.release(); } | |
435 | ||
436 | JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
437 | ||
438 | private: | |
439 | friend class ArrayNode; | |
440 | ListRefPtr<ElementNode> m_next; | |
441 | int m_elision; | |
442 | RefPtr<ExpressionNode> m_node; | |
443 | }; | |
444 | ||
445 | class ArrayNode : public ExpressionNode { | |
446 | public: | |
447 | ArrayNode(int elision) KJS_FAST_CALL | |
448 | : m_elision(elision) | |
449 | , m_optional(true) | |
450 | { | |
451 | } | |
452 | ||
453 | ArrayNode(ElementNode* element) KJS_FAST_CALL | |
454 | : m_element(element) | |
455 | , m_elision(0) | |
456 | , m_optional(false) | |
457 | { | |
458 | } | |
459 | ||
460 | ArrayNode(int elision, ElementNode* element) KJS_FAST_CALL | |
461 | : m_element(element) | |
462 | , m_elision(elision) | |
463 | , m_optional(true) | |
464 | { | |
465 | } | |
466 | ||
467 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
468 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
469 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
470 | virtual Precedence precedence() const { return PrecPrimary; } | |
471 | ||
472 | private: | |
473 | RefPtr<ElementNode> m_element; | |
474 | int m_elision; | |
475 | bool m_optional; | |
476 | }; | |
477 | ||
478 | class PropertyNode : public Node { | |
479 | public: | |
480 | enum Type { Constant, Getter, Setter }; | |
481 | ||
482 | PropertyNode(const Identifier& name, ExpressionNode* assign, Type type) KJS_FAST_CALL | |
483 | : m_name(name) | |
484 | , m_assign(assign) | |
485 | , m_type(type) | |
486 | { | |
487 | } | |
488 | ||
489 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
490 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
491 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
492 | ||
493 | JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
494 | const Identifier& name() const { return m_name; } | |
495 | ||
496 | private: | |
497 | friend class PropertyListNode; | |
498 | Identifier m_name; | |
499 | RefPtr<ExpressionNode> m_assign; | |
500 | Type m_type; | |
501 | }; | |
502 | ||
503 | class PropertyListNode : public Node { | |
504 | public: | |
505 | PropertyListNode(PropertyNode* node) KJS_FAST_CALL | |
506 | : m_node(node) | |
507 | { | |
508 | } | |
509 | ||
510 | PropertyListNode(PropertyNode* node, PropertyListNode* list) KJS_FAST_CALL | |
511 | : m_node(node) | |
512 | { | |
513 | list->m_next = this; | |
514 | } | |
515 | ||
516 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
517 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
518 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
519 | ||
520 | JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
521 | PassRefPtr<PropertyListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); } | |
522 | ||
523 | private: | |
524 | friend class ObjectLiteralNode; | |
525 | RefPtr<PropertyNode> m_node; | |
526 | ListRefPtr<PropertyListNode> m_next; | |
527 | }; | |
528 | ||
529 | class ObjectLiteralNode : public ExpressionNode { | |
530 | public: | |
531 | ObjectLiteralNode() KJS_FAST_CALL | |
532 | { | |
533 | } | |
534 | ||
535 | ObjectLiteralNode(PropertyListNode* list) KJS_FAST_CALL | |
536 | : m_list(list) | |
537 | { | |
538 | } | |
539 | ||
540 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
541 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
542 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
543 | virtual Precedence precedence() const { return PrecPrimary; } | |
544 | virtual bool needsParensIfLeftmost() const { return true; } | |
545 | ||
546 | private: | |
547 | RefPtr<PropertyListNode> m_list; | |
548 | }; | |
549 | ||
550 | class BracketAccessorNode : public ExpressionNode { | |
551 | public: | |
552 | BracketAccessorNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL | |
553 | : m_base(base) | |
554 | , m_subscript(subscript) | |
555 | { | |
556 | } | |
557 | ||
558 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
559 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
560 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
561 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
562 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
563 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
564 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
565 | virtual Precedence precedence() const { return PrecMember; } | |
566 | ||
567 | virtual bool isLocation() const KJS_FAST_CALL { return true; } | |
568 | virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return true; } | |
569 | ExpressionNode* base() KJS_FAST_CALL { return m_base.get(); } | |
570 | ExpressionNode* subscript() KJS_FAST_CALL { return m_subscript.get(); } | |
571 | ||
572 | private: | |
573 | ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*); | |
574 | ||
575 | RefPtr<ExpressionNode> m_base; | |
576 | RefPtr<ExpressionNode> m_subscript; | |
577 | }; | |
578 | ||
579 | class DotAccessorNode : public ExpressionNode { | |
580 | public: | |
581 | DotAccessorNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL | |
582 | : m_base(base) | |
583 | , m_ident(ident) | |
584 | { | |
585 | } | |
586 | ||
587 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
588 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
589 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
590 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
591 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
592 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
593 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
594 | virtual Precedence precedence() const { return PrecMember; } | |
595 | ||
596 | virtual bool isLocation() const KJS_FAST_CALL { return true; } | |
597 | virtual bool isDotAccessorNode() const KJS_FAST_CALL { return true; } | |
598 | ExpressionNode* base() const KJS_FAST_CALL { return m_base.get(); } | |
599 | const Identifier& identifier() const KJS_FAST_CALL { return m_ident; } | |
600 | ||
601 | private: | |
602 | ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*); | |
603 | ||
604 | RefPtr<ExpressionNode> m_base; | |
605 | Identifier m_ident; | |
606 | }; | |
607 | ||
608 | class ArgumentListNode : public Node { | |
609 | public: | |
610 | ArgumentListNode(ExpressionNode* expr) KJS_FAST_CALL | |
611 | : m_expr(expr) | |
612 | { | |
613 | } | |
614 | ||
615 | ArgumentListNode(ArgumentListNode* listNode, ExpressionNode* expr) KJS_FAST_CALL | |
616 | : m_expr(expr) | |
617 | { | |
618 | listNode->m_next = this; | |
619 | } | |
620 | ||
621 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
622 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
623 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
624 | ||
625 | void evaluateList(ExecState*, List&) KJS_FAST_CALL; | |
626 | PassRefPtr<ArgumentListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); } | |
627 | ||
628 | private: | |
629 | friend class ArgumentsNode; | |
630 | ListRefPtr<ArgumentListNode> m_next; | |
631 | RefPtr<ExpressionNode> m_expr; | |
632 | }; | |
633 | ||
634 | class ArgumentsNode : public Node { | |
635 | public: | |
636 | ArgumentsNode() KJS_FAST_CALL | |
637 | { | |
638 | } | |
639 | ||
640 | ArgumentsNode(ArgumentListNode* listNode) KJS_FAST_CALL | |
641 | : m_listNode(listNode) | |
642 | { | |
643 | } | |
644 | ||
645 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
646 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
647 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
648 | ||
649 | void evaluateList(ExecState* exec, List& list) KJS_FAST_CALL { if (m_listNode) m_listNode->evaluateList(exec, list); } | |
650 | ||
651 | private: | |
652 | RefPtr<ArgumentListNode> m_listNode; | |
653 | }; | |
654 | ||
655 | class NewExprNode : public ExpressionNode { | |
656 | public: | |
657 | NewExprNode(ExpressionNode* expr) KJS_FAST_CALL | |
658 | : m_expr(expr) | |
659 | { | |
660 | } | |
661 | ||
662 | NewExprNode(ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL | |
663 | : m_expr(expr) | |
664 | , m_args(args) | |
665 | { | |
666 | } | |
667 | ||
668 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
669 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
670 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
671 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
672 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
673 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
674 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
675 | virtual Precedence precedence() const { return PrecLeftHandSide; } | |
676 | ||
677 | private: | |
678 | ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*); | |
679 | ||
680 | RefPtr<ExpressionNode> m_expr; | |
681 | RefPtr<ArgumentsNode> m_args; | |
682 | }; | |
683 | ||
684 | class FunctionCallValueNode : public ExpressionNode { | |
685 | public: | |
686 | FunctionCallValueNode(ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL | |
687 | : m_expr(expr) | |
688 | , m_args(args) | |
689 | { | |
690 | } | |
691 | ||
692 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
693 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
694 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
695 | virtual Precedence precedence() const { return PrecCall; } | |
696 | ||
697 | private: | |
698 | RefPtr<ExpressionNode> m_expr; | |
699 | RefPtr<ArgumentsNode> m_args; | |
700 | }; | |
701 | ||
702 | class FunctionCallResolveNode : public ExpressionNode { | |
703 | public: | |
704 | FunctionCallResolveNode(const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL | |
705 | : m_ident(ident) | |
706 | , m_args(args) | |
707 | { | |
708 | } | |
709 | ||
710 | FunctionCallResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
711 | : ExpressionNode(PlacementNewAdopt) | |
712 | , m_ident(PlacementNewAdopt) | |
713 | , m_args(PlacementNewAdopt) | |
714 | { | |
715 | } | |
716 | ||
717 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
718 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
719 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
720 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
721 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
722 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
723 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
724 | virtual Precedence precedence() const { return PrecCall; } | |
725 | ||
726 | protected: | |
727 | ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*); | |
728 | ||
729 | Identifier m_ident; | |
730 | RefPtr<ArgumentsNode> m_args; | |
731 | size_t m_index; // Used by LocalVarFunctionCallNode. | |
732 | }; | |
733 | ||
734 | class LocalVarFunctionCallNode : public FunctionCallResolveNode { | |
735 | public: | |
736 | LocalVarFunctionCallNode(size_t i) KJS_FAST_CALL | |
737 | : FunctionCallResolveNode(PlacementNewAdopt) | |
738 | { | |
739 | ASSERT(i != missingSymbolMarker()); | |
740 | m_index = i; | |
741 | } | |
742 | ||
743 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
744 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
745 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
746 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
747 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
748 | ||
749 | private: | |
750 | ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*); | |
751 | }; | |
752 | ||
753 | class FunctionCallBracketNode : public ExpressionNode { | |
754 | public: | |
755 | FunctionCallBracketNode(ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args) KJS_FAST_CALL | |
756 | : m_base(base) | |
757 | , m_subscript(subscript) | |
758 | , m_args(args) | |
759 | { | |
760 | } | |
761 | ||
762 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
763 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
764 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
765 | virtual Precedence precedence() const { return PrecCall; } | |
766 | ||
767 | protected: | |
768 | RefPtr<ExpressionNode> m_base; | |
769 | RefPtr<ExpressionNode> m_subscript; | |
770 | RefPtr<ArgumentsNode> m_args; | |
771 | }; | |
772 | ||
773 | class FunctionCallDotNode : public ExpressionNode { | |
774 | public: | |
775 | FunctionCallDotNode(ExpressionNode* base, const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL | |
776 | : m_base(base) | |
777 | , m_ident(ident) | |
778 | , m_args(args) | |
779 | { | |
780 | } | |
781 | ||
782 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
783 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
784 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
785 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
786 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
787 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
788 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
789 | virtual Precedence precedence() const { return PrecCall; } | |
790 | ||
791 | private: | |
792 | ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*); | |
793 | ||
794 | RefPtr<ExpressionNode> m_base; | |
795 | Identifier m_ident; | |
796 | RefPtr<ArgumentsNode> m_args; | |
797 | }; | |
798 | ||
799 | class PrePostResolveNode : public ExpressionNode { | |
800 | public: | |
801 | PrePostResolveNode(const Identifier& ident) KJS_FAST_CALL | |
802 | : ExpressionNode(NumberType) | |
803 | , m_ident(ident) | |
804 | { | |
805 | } | |
806 | ||
807 | PrePostResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
808 | : ExpressionNode(PlacementNewAdopt) | |
809 | , m_ident(PlacementNewAdopt) | |
810 | { | |
811 | } | |
812 | ||
813 | protected: | |
814 | Identifier m_ident; | |
815 | size_t m_index; // Used by LocalVarPostfixNode. | |
816 | }; | |
817 | ||
818 | class PostIncResolveNode : public PrePostResolveNode { | |
819 | public: | |
820 | PostIncResolveNode(const Identifier& ident) KJS_FAST_CALL | |
821 | : PrePostResolveNode(ident) | |
822 | { | |
823 | } | |
824 | ||
825 | PostIncResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
826 | : PrePostResolveNode(PlacementNewAdopt) | |
827 | { | |
828 | } | |
829 | ||
830 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
831 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
832 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
833 | virtual Precedence precedence() const { return PrecPostfix; } | |
834 | virtual void optimizeForUnnecessaryResult(); | |
835 | }; | |
836 | ||
837 | class PostIncLocalVarNode : public PostIncResolveNode { | |
838 | public: | |
839 | PostIncLocalVarNode(size_t i) KJS_FAST_CALL | |
840 | : PostIncResolveNode(PlacementNewAdopt) | |
841 | { | |
842 | ASSERT(i != missingSymbolMarker()); | |
843 | m_index = i; | |
844 | } | |
845 | ||
846 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
847 | virtual void optimizeForUnnecessaryResult(); | |
848 | }; | |
849 | ||
850 | class PostIncConstNode : public PostIncResolveNode { | |
851 | public: | |
852 | PostIncConstNode(size_t i) KJS_FAST_CALL | |
853 | : PostIncResolveNode(PlacementNewAdopt) | |
854 | { | |
855 | ASSERT(i != missingSymbolMarker()); | |
856 | m_index = i; | |
857 | } | |
858 | ||
859 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
860 | }; | |
861 | ||
862 | class PostDecResolveNode : public PrePostResolveNode { | |
863 | public: | |
864 | PostDecResolveNode(const Identifier& ident) KJS_FAST_CALL | |
865 | : PrePostResolveNode(ident) | |
866 | { | |
867 | } | |
868 | ||
869 | PostDecResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
870 | : PrePostResolveNode(PlacementNewAdopt) | |
871 | { | |
872 | } | |
873 | ||
874 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
875 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
876 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
877 | virtual Precedence precedence() const { return PrecPostfix; } | |
878 | virtual void optimizeForUnnecessaryResult(); | |
879 | }; | |
880 | ||
881 | class PostDecLocalVarNode : public PostDecResolveNode { | |
882 | public: | |
883 | PostDecLocalVarNode(size_t i) KJS_FAST_CALL | |
884 | : PostDecResolveNode(PlacementNewAdopt) | |
885 | { | |
886 | ASSERT(i != missingSymbolMarker()); | |
887 | m_index = i; | |
888 | } | |
889 | ||
890 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
891 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
892 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
893 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
894 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
895 | virtual void optimizeForUnnecessaryResult(); | |
896 | ||
897 | private: | |
898 | ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*); | |
899 | }; | |
900 | ||
901 | class PostDecConstNode : public PostDecResolveNode { | |
902 | public: | |
903 | PostDecConstNode(size_t i) KJS_FAST_CALL | |
904 | : PostDecResolveNode(PlacementNewAdopt) | |
905 | { | |
906 | ASSERT(i != missingSymbolMarker()); | |
907 | m_index = i; | |
908 | } | |
909 | ||
910 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
911 | }; | |
912 | ||
913 | class PostfixBracketNode : public ExpressionNode { | |
914 | public: | |
915 | PostfixBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL | |
916 | : m_base(base) | |
917 | , m_subscript(subscript) | |
918 | { | |
919 | } | |
920 | ||
921 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
922 | virtual Precedence precedence() const { return PrecPostfix; } | |
923 | ||
924 | protected: | |
925 | RefPtr<ExpressionNode> m_base; | |
926 | RefPtr<ExpressionNode> m_subscript; | |
927 | }; | |
928 | ||
929 | class PostIncBracketNode : public PostfixBracketNode { | |
930 | public: | |
931 | PostIncBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL | |
932 | : PostfixBracketNode(base, subscript) | |
933 | { | |
934 | } | |
935 | ||
936 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
937 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
938 | }; | |
939 | ||
940 | class PostDecBracketNode : public PostfixBracketNode { | |
941 | public: | |
942 | PostDecBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL | |
943 | : PostfixBracketNode(base, subscript) | |
944 | { | |
945 | } | |
946 | ||
947 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
948 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
949 | }; | |
950 | ||
951 | class PostfixDotNode : public ExpressionNode { | |
952 | public: | |
953 | PostfixDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL | |
954 | : m_base(base) | |
955 | , m_ident(ident) | |
956 | { | |
957 | } | |
958 | ||
959 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
960 | virtual Precedence precedence() const { return PrecPostfix; } | |
961 | ||
962 | protected: | |
963 | RefPtr<ExpressionNode> m_base; | |
964 | Identifier m_ident; | |
965 | }; | |
966 | ||
967 | class PostIncDotNode : public PostfixDotNode { | |
968 | public: | |
969 | PostIncDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL | |
970 | : PostfixDotNode(base, ident) | |
971 | { | |
972 | } | |
973 | ||
974 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
975 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
976 | }; | |
977 | ||
978 | class PostDecDotNode : public PostfixDotNode { | |
979 | public: | |
980 | PostDecDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL | |
981 | : PostfixDotNode(base, ident) | |
982 | { | |
983 | } | |
984 | ||
985 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
986 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
987 | }; | |
988 | ||
989 | class PostfixErrorNode : public ExpressionNode { | |
990 | public: | |
991 | PostfixErrorNode(ExpressionNode* expr, Operator oper) KJS_FAST_CALL | |
992 | : m_expr(expr) | |
993 | , m_operator(oper) | |
994 | { | |
995 | } | |
996 | ||
997 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
998 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
999 | virtual Precedence precedence() const { return PrecPostfix; } | |
1000 | ||
1001 | private: | |
1002 | RefPtr<ExpressionNode> m_expr; | |
1003 | Operator m_operator; | |
1004 | }; | |
1005 | ||
1006 | class DeleteResolveNode : public ExpressionNode { | |
1007 | public: | |
1008 | DeleteResolveNode(const Identifier& ident) KJS_FAST_CALL | |
1009 | : m_ident(ident) | |
1010 | { | |
1011 | } | |
1012 | ||
1013 | DeleteResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
1014 | : ExpressionNode(PlacementNewAdopt) | |
1015 | , m_ident(PlacementNewAdopt) | |
1016 | { | |
1017 | } | |
1018 | ||
1019 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1020 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1021 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1022 | virtual Precedence precedence() const { return PrecUnary; } | |
1023 | ||
1024 | private: | |
1025 | Identifier m_ident; | |
1026 | }; | |
1027 | ||
1028 | class LocalVarDeleteNode : public DeleteResolveNode { | |
1029 | public: | |
1030 | LocalVarDeleteNode() KJS_FAST_CALL | |
1031 | : DeleteResolveNode(PlacementNewAdopt) | |
1032 | { | |
1033 | } | |
1034 | ||
1035 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1036 | }; | |
1037 | ||
1038 | class DeleteBracketNode : public ExpressionNode { | |
1039 | public: | |
1040 | DeleteBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL | |
1041 | : m_base(base) | |
1042 | , m_subscript(subscript) | |
1043 | { | |
1044 | } | |
1045 | ||
1046 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1047 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1048 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1049 | virtual Precedence precedence() const { return PrecUnary; } | |
1050 | ||
1051 | private: | |
1052 | RefPtr<ExpressionNode> m_base; | |
1053 | RefPtr<ExpressionNode> m_subscript; | |
1054 | }; | |
1055 | ||
1056 | class DeleteDotNode : public ExpressionNode { | |
1057 | public: | |
1058 | DeleteDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL | |
1059 | : m_base(base) | |
1060 | , m_ident(ident) | |
1061 | { | |
1062 | } | |
1063 | ||
1064 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1065 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1066 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1067 | virtual Precedence precedence() const { return PrecUnary; } | |
1068 | ||
1069 | private: | |
1070 | RefPtr<ExpressionNode> m_base; | |
1071 | Identifier m_ident; | |
1072 | }; | |
1073 | ||
1074 | class DeleteValueNode : public ExpressionNode { | |
1075 | public: | |
1076 | DeleteValueNode(ExpressionNode* expr) KJS_FAST_CALL | |
1077 | : m_expr(expr) | |
1078 | { | |
1079 | } | |
1080 | ||
1081 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1082 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1083 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1084 | virtual Precedence precedence() const { return PrecUnary; } | |
1085 | ||
1086 | private: | |
1087 | RefPtr<ExpressionNode> m_expr; | |
1088 | }; | |
1089 | ||
1090 | class VoidNode : public ExpressionNode { | |
1091 | public: | |
1092 | VoidNode(ExpressionNode* expr) KJS_FAST_CALL | |
1093 | : m_expr(expr) | |
1094 | { | |
1095 | } | |
1096 | ||
1097 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1098 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1099 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1100 | virtual Precedence precedence() const { return PrecUnary; } | |
1101 | ||
1102 | private: | |
1103 | RefPtr<ExpressionNode> m_expr; | |
1104 | }; | |
1105 | ||
1106 | class TypeOfResolveNode : public ExpressionNode { | |
1107 | public: | |
1108 | TypeOfResolveNode(const Identifier& ident) KJS_FAST_CALL | |
1109 | : ExpressionNode(StringType) | |
1110 | , m_ident(ident) | |
1111 | { | |
1112 | } | |
1113 | ||
1114 | TypeOfResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
1115 | : ExpressionNode(PlacementNewAdopt) | |
1116 | , m_ident(PlacementNewAdopt) | |
1117 | { | |
1118 | m_expectedReturnType = StringType; | |
1119 | } | |
1120 | ||
1121 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1122 | ||
1123 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1124 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1125 | virtual Precedence precedence() const { return PrecUnary; } | |
1126 | ||
1127 | const Identifier& identifier() const KJS_FAST_CALL { return m_ident; } | |
1128 | ||
1129 | protected: | |
1130 | Identifier m_ident; | |
1131 | size_t m_index; // Used by LocalTypeOfNode. | |
1132 | }; | |
1133 | ||
1134 | class LocalVarTypeOfNode : public TypeOfResolveNode { | |
1135 | public: | |
1136 | LocalVarTypeOfNode(size_t i) KJS_FAST_CALL | |
1137 | : TypeOfResolveNode(PlacementNewAdopt) | |
1138 | { | |
1139 | m_expectedReturnType = StringType; | |
1140 | ASSERT(i != missingSymbolMarker()); | |
1141 | m_index = i; | |
1142 | } | |
1143 | ||
1144 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1145 | }; | |
1146 | ||
1147 | class TypeOfValueNode : public ExpressionNode { | |
1148 | public: | |
1149 | TypeOfValueNode(ExpressionNode* expr) KJS_FAST_CALL | |
1150 | : ExpressionNode(StringType) | |
1151 | , m_expr(expr) | |
1152 | { | |
1153 | } | |
1154 | ||
1155 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1156 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1157 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1158 | virtual Precedence precedence() const { return PrecUnary; } | |
1159 | ||
1160 | private: | |
1161 | RefPtr<ExpressionNode> m_expr; | |
1162 | }; | |
1163 | ||
1164 | class PreIncResolveNode : public PrePostResolveNode { | |
1165 | public: | |
1166 | PreIncResolveNode(const Identifier& ident) KJS_FAST_CALL | |
1167 | : PrePostResolveNode(ident) | |
1168 | { | |
1169 | } | |
1170 | ||
1171 | PreIncResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
1172 | : PrePostResolveNode(PlacementNewAdopt) | |
1173 | { | |
1174 | } | |
1175 | ||
1176 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1177 | ||
1178 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1179 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1180 | virtual Precedence precedence() const { return PrecUnary; } | |
1181 | }; | |
1182 | ||
1183 | class PreIncLocalVarNode : public PreIncResolveNode { | |
1184 | public: | |
1185 | PreIncLocalVarNode(size_t i) KJS_FAST_CALL | |
1186 | : PreIncResolveNode(PlacementNewAdopt) | |
1187 | { | |
1188 | ASSERT(i != missingSymbolMarker()); | |
1189 | m_index = i; | |
1190 | } | |
1191 | ||
1192 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1193 | }; | |
1194 | ||
1195 | class PreIncConstNode : public PreIncResolveNode { | |
1196 | public: | |
1197 | PreIncConstNode(size_t i) KJS_FAST_CALL | |
1198 | : PreIncResolveNode(PlacementNewAdopt) | |
1199 | { | |
1200 | ASSERT(i != missingSymbolMarker()); | |
1201 | m_index = i; | |
1202 | } | |
1203 | ||
1204 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1205 | }; | |
1206 | ||
1207 | class PreDecResolveNode : public PrePostResolveNode { | |
1208 | public: | |
1209 | PreDecResolveNode(const Identifier& ident) KJS_FAST_CALL | |
1210 | : PrePostResolveNode(ident) | |
1211 | { | |
1212 | } | |
1213 | ||
1214 | PreDecResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
1215 | : PrePostResolveNode(PlacementNewAdopt) | |
1216 | { | |
1217 | } | |
1218 | ||
1219 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1220 | ||
1221 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1222 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1223 | virtual Precedence precedence() const { return PrecUnary; } | |
1224 | }; | |
1225 | ||
1226 | class PreDecLocalVarNode : public PreDecResolveNode { | |
1227 | public: | |
1228 | PreDecLocalVarNode(size_t i) KJS_FAST_CALL | |
1229 | : PreDecResolveNode(PlacementNewAdopt) | |
1230 | { | |
1231 | ASSERT(i != missingSymbolMarker()); | |
1232 | m_index = i; | |
1233 | } | |
1234 | ||
1235 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1236 | }; | |
1237 | ||
1238 | class PreDecConstNode : public PreDecResolveNode { | |
1239 | public: | |
1240 | PreDecConstNode(size_t i) KJS_FAST_CALL | |
1241 | : PreDecResolveNode(PlacementNewAdopt) | |
1242 | { | |
1243 | ASSERT(i != missingSymbolMarker()); | |
1244 | m_index = i; | |
1245 | } | |
1246 | ||
1247 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1248 | }; | |
1249 | ||
1250 | class PrefixBracketNode : public ExpressionNode { | |
1251 | public: | |
1252 | PrefixBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL | |
1253 | : m_base(base) | |
1254 | , m_subscript(subscript) | |
1255 | { | |
1256 | } | |
1257 | ||
1258 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1259 | virtual Precedence precedence() const { return PrecUnary; } | |
1260 | ||
1261 | protected: | |
1262 | RefPtr<ExpressionNode> m_base; | |
1263 | RefPtr<ExpressionNode> m_subscript; | |
1264 | }; | |
1265 | ||
1266 | class PreIncBracketNode : public PrefixBracketNode { | |
1267 | public: | |
1268 | PreIncBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL | |
1269 | : PrefixBracketNode(base, subscript) | |
1270 | { | |
1271 | } | |
1272 | ||
1273 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1274 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1275 | }; | |
1276 | ||
1277 | class PreDecBracketNode : public PrefixBracketNode { | |
1278 | public: | |
1279 | PreDecBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL | |
1280 | : PrefixBracketNode(base, subscript) | |
1281 | { | |
1282 | } | |
1283 | ||
1284 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1285 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1286 | }; | |
1287 | ||
1288 | class PrefixDotNode : public ExpressionNode { | |
1289 | public: | |
1290 | PrefixDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL | |
1291 | : m_base(base) | |
1292 | , m_ident(ident) | |
1293 | { | |
1294 | } | |
1295 | ||
1296 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1297 | virtual Precedence precedence() const { return PrecPostfix; } | |
1298 | ||
1299 | protected: | |
1300 | RefPtr<ExpressionNode> m_base; | |
1301 | Identifier m_ident; | |
1302 | }; | |
1303 | ||
1304 | class PreIncDotNode : public PrefixDotNode { | |
1305 | public: | |
1306 | PreIncDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL | |
1307 | : PrefixDotNode(base, ident) | |
1308 | { | |
1309 | } | |
1310 | ||
1311 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1312 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1313 | }; | |
1314 | ||
1315 | class PreDecDotNode : public PrefixDotNode { | |
1316 | public: | |
1317 | PreDecDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL | |
1318 | : PrefixDotNode(base, ident) | |
1319 | { | |
1320 | } | |
1321 | ||
1322 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1323 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1324 | }; | |
1325 | ||
1326 | class PrefixErrorNode : public ExpressionNode { | |
1327 | public: | |
1328 | PrefixErrorNode(ExpressionNode* expr, Operator oper) KJS_FAST_CALL | |
1329 | : m_expr(expr) | |
1330 | , m_operator(oper) | |
1331 | { | |
1332 | } | |
1333 | ||
1334 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1335 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1336 | virtual Precedence precedence() const { return PrecUnary; } | |
1337 | ||
1338 | private: | |
1339 | RefPtr<ExpressionNode> m_expr; | |
1340 | Operator m_operator; | |
1341 | }; | |
1342 | ||
1343 | class UnaryPlusNode : public ExpressionNode { | |
1344 | public: | |
1345 | UnaryPlusNode(ExpressionNode* expr) KJS_FAST_CALL | |
1346 | : ExpressionNode(NumberType) | |
1347 | , m_expr(expr) | |
1348 | { | |
1349 | } | |
1350 | ||
1351 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1352 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1353 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1354 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1355 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1356 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1357 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1358 | virtual Precedence precedence() const { return PrecUnary; } | |
1359 | ||
1360 | private: | |
1361 | RefPtr<ExpressionNode> m_expr; | |
1362 | }; | |
1363 | ||
1364 | class NegateNode : public ExpressionNode { | |
1365 | public: | |
1366 | NegateNode(ExpressionNode* expr) KJS_FAST_CALL | |
1367 | : ExpressionNode(NumberType) | |
1368 | , m_expr(expr) | |
1369 | { | |
1370 | } | |
1371 | ||
1372 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1373 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1374 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1375 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1376 | virtual Precedence precedence() const { return PrecUnary; } | |
1377 | ||
1378 | private: | |
1379 | RefPtr<ExpressionNode> m_expr; | |
1380 | }; | |
1381 | ||
1382 | class BitwiseNotNode : public ExpressionNode { | |
1383 | public: | |
1384 | BitwiseNotNode(ExpressionNode* expr) KJS_FAST_CALL | |
1385 | : ExpressionNode(NumberType) | |
1386 | , m_expr(expr) | |
1387 | { | |
1388 | } | |
1389 | ||
1390 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1391 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1392 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1393 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1394 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1395 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1396 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1397 | virtual Precedence precedence() const { return PrecUnary; } | |
1398 | ||
1399 | private: | |
1400 | ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*); | |
1401 | ||
1402 | RefPtr<ExpressionNode> m_expr; | |
1403 | }; | |
1404 | ||
1405 | class LogicalNotNode : public ExpressionNode { | |
1406 | public: | |
1407 | LogicalNotNode(ExpressionNode* expr) KJS_FAST_CALL | |
1408 | : ExpressionNode(BooleanType) | |
1409 | , m_expr(expr) | |
1410 | { | |
1411 | } | |
1412 | ||
1413 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1414 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1415 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1416 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1417 | virtual Precedence precedence() const { return PrecUnary; } | |
1418 | ||
1419 | private: | |
1420 | RefPtr<ExpressionNode> m_expr; | |
1421 | }; | |
1422 | ||
1423 | class MultNode : public ExpressionNode { | |
1424 | public: | |
1425 | MultNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1426 | : ExpressionNode(NumberType) | |
1427 | , m_term1(term1) | |
1428 | , m_term2(term2) | |
1429 | { | |
1430 | } | |
1431 | ||
1432 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1433 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1434 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1435 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1436 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1437 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1438 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1439 | virtual Precedence precedence() const { return PrecMultiplicitave; } | |
1440 | ||
1441 | private: | |
1442 | ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*); | |
1443 | ||
1444 | RefPtr<ExpressionNode> m_term1; | |
1445 | RefPtr<ExpressionNode> m_term2; | |
1446 | }; | |
1447 | ||
1448 | class DivNode : public ExpressionNode { | |
1449 | public: | |
1450 | DivNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1451 | : ExpressionNode(NumberType) | |
1452 | , m_term1(term1) | |
1453 | , m_term2(term2) | |
1454 | { | |
1455 | } | |
1456 | ||
1457 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1458 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1459 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1460 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1461 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1462 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1463 | virtual Precedence precedence() const { return PrecMultiplicitave; } | |
1464 | ||
1465 | private: | |
1466 | ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*); | |
1467 | ||
1468 | RefPtr<ExpressionNode> m_term1; | |
1469 | RefPtr<ExpressionNode> m_term2; | |
1470 | }; | |
1471 | ||
1472 | class ModNode : public ExpressionNode { | |
1473 | public: | |
1474 | ModNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1475 | : ExpressionNode(NumberType) | |
1476 | , m_term1(term1) | |
1477 | , m_term2(term2) | |
1478 | { | |
1479 | } | |
1480 | ||
1481 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1482 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1483 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1484 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1485 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1486 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1487 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1488 | virtual Precedence precedence() const { return PrecMultiplicitave; } | |
1489 | ||
1490 | private: | |
1491 | ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*); | |
1492 | ||
1493 | RefPtr<ExpressionNode> m_term1; | |
1494 | RefPtr<ExpressionNode> m_term2; | |
1495 | }; | |
1496 | ||
1497 | class AddNode : public ExpressionNode { | |
1498 | public: | |
1499 | AddNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1500 | : m_term1(term1) | |
1501 | , m_term2(term2) | |
1502 | { | |
1503 | } | |
1504 | ||
1505 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1506 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1507 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1508 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1509 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1510 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1511 | virtual Precedence precedence() const { return PrecAdditive; } | |
1512 | ||
1513 | protected: | |
1514 | AddNode(ExpressionNode* term1, ExpressionNode* term2, JSType expectedReturn) KJS_FAST_CALL | |
1515 | : ExpressionNode(expectedReturn) | |
1516 | , m_term1(term1) | |
1517 | , m_term2(term2) | |
1518 | { | |
1519 | } | |
1520 | ||
1521 | RefPtr<ExpressionNode> m_term1; | |
1522 | RefPtr<ExpressionNode> m_term2; | |
1523 | ||
1524 | private: | |
1525 | ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*); | |
1526 | }; | |
1527 | ||
1528 | class AddNumbersNode : public AddNode { | |
1529 | public: | |
1530 | AddNumbersNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1531 | : AddNode(term1, term2, NumberType) | |
1532 | { | |
1533 | } | |
1534 | ||
1535 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1536 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1537 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1538 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1539 | ||
1540 | private: | |
1541 | ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1542 | }; | |
1543 | ||
1544 | class AddStringLeftNode : public AddNode { | |
1545 | public: | |
1546 | AddStringLeftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1547 | : AddNode(term1, term2, StringType) | |
1548 | { | |
1549 | } | |
1550 | ||
1551 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1552 | }; | |
1553 | ||
1554 | class AddStringRightNode : public AddNode { | |
1555 | public: | |
1556 | AddStringRightNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1557 | : AddNode(term1, term2, StringType) | |
1558 | { | |
1559 | } | |
1560 | ||
1561 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1562 | }; | |
1563 | ||
1564 | class AddStringsNode : public AddNode { | |
1565 | public: | |
1566 | AddStringsNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1567 | : AddNode(term1, term2, StringType) | |
1568 | { | |
1569 | } | |
1570 | ||
1571 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1572 | }; | |
1573 | ||
1574 | class SubNode : public ExpressionNode { | |
1575 | public: | |
1576 | SubNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1577 | : ExpressionNode(NumberType) | |
1578 | , m_term1(term1) | |
1579 | , m_term2(term2) | |
1580 | { | |
1581 | } | |
1582 | ||
1583 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1584 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1585 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1586 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1587 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1588 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1589 | virtual Precedence precedence() const { return PrecAdditive; } | |
1590 | ||
1591 | private: | |
1592 | ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*); | |
1593 | ||
1594 | RefPtr<ExpressionNode> m_term1; | |
1595 | RefPtr<ExpressionNode> m_term2; | |
1596 | }; | |
1597 | ||
1598 | class LeftShiftNode : public ExpressionNode { | |
1599 | public: | |
1600 | LeftShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1601 | : ExpressionNode(NumberType) | |
1602 | , m_term1(term1) | |
1603 | , m_term2(term2) | |
1604 | { | |
1605 | } | |
1606 | ||
1607 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1608 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1609 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1610 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1611 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1612 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1613 | virtual Precedence precedence() const { return PrecShift; } | |
1614 | ||
1615 | private: | |
1616 | ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*); | |
1617 | ||
1618 | RefPtr<ExpressionNode> m_term1; | |
1619 | RefPtr<ExpressionNode> m_term2; | |
1620 | }; | |
1621 | ||
1622 | class RightShiftNode : public ExpressionNode { | |
1623 | public: | |
1624 | RightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1625 | : ExpressionNode(NumberType) | |
1626 | , m_term1(term1) | |
1627 | , m_term2(term2) | |
1628 | { | |
1629 | } | |
1630 | ||
1631 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1632 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1633 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1634 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1635 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1636 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1637 | virtual Precedence precedence() const { return PrecShift; } | |
1638 | ||
1639 | private: | |
1640 | ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*); | |
1641 | ||
1642 | RefPtr<ExpressionNode> m_term1; | |
1643 | RefPtr<ExpressionNode> m_term2; | |
1644 | }; | |
1645 | ||
1646 | class UnsignedRightShiftNode : public ExpressionNode { | |
1647 | public: | |
1648 | UnsignedRightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL | |
1649 | : ExpressionNode(NumberType) | |
1650 | , m_term1(term1) | |
1651 | , m_term2(term2) | |
1652 | { | |
1653 | } | |
1654 | ||
1655 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1656 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1657 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1658 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1659 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1660 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1661 | virtual Precedence precedence() const { return PrecShift; } | |
1662 | private: | |
1663 | ALWAYS_INLINE uint32_t inlineEvaluateToUInt32(ExecState*); | |
1664 | ||
1665 | RefPtr<ExpressionNode> m_term1; | |
1666 | RefPtr<ExpressionNode> m_term2; | |
1667 | }; | |
1668 | ||
1669 | class LessNode : public ExpressionNode { | |
1670 | public: | |
1671 | LessNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1672 | : ExpressionNode(BooleanType) | |
1673 | , m_expr1(expr1) | |
1674 | , m_expr2(expr2) | |
1675 | { | |
1676 | } | |
1677 | ||
1678 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1679 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1680 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1681 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1682 | virtual Precedence precedence() const { return PrecRelational; } | |
1683 | ||
1684 | private: | |
1685 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
1686 | ||
1687 | protected: | |
1688 | RefPtr<ExpressionNode> m_expr1; | |
1689 | RefPtr<ExpressionNode> m_expr2; | |
1690 | }; | |
1691 | ||
1692 | class LessNumbersNode : public LessNode { | |
1693 | public: | |
1694 | LessNumbersNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1695 | : LessNode(expr1, expr2) | |
1696 | { | |
1697 | } | |
1698 | ||
1699 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1700 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1701 | ||
1702 | private: | |
1703 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
1704 | }; | |
1705 | ||
1706 | class LessStringsNode : public LessNode { | |
1707 | public: | |
1708 | LessStringsNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1709 | : LessNode(expr1, expr2) | |
1710 | { | |
1711 | } | |
1712 | ||
1713 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1714 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1715 | ||
1716 | private: | |
1717 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
1718 | }; | |
1719 | ||
1720 | class GreaterNode : public ExpressionNode { | |
1721 | public: | |
1722 | GreaterNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1723 | : m_expr1(expr1) | |
1724 | , m_expr2(expr2) | |
1725 | { | |
1726 | } | |
1727 | ||
1728 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1729 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1730 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1731 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1732 | virtual Precedence precedence() const { return PrecRelational; } | |
1733 | ||
1734 | private: | |
1735 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
1736 | ||
1737 | RefPtr<ExpressionNode> m_expr1; | |
1738 | RefPtr<ExpressionNode> m_expr2; | |
1739 | }; | |
1740 | ||
1741 | class LessEqNode : public ExpressionNode { | |
1742 | public: | |
1743 | LessEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1744 | : m_expr1(expr1) | |
1745 | , m_expr2(expr2) | |
1746 | { | |
1747 | } | |
1748 | ||
1749 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1750 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1751 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1752 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1753 | virtual Precedence precedence() const { return PrecRelational; } | |
1754 | ||
1755 | private: | |
1756 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
1757 | ||
1758 | RefPtr<ExpressionNode> m_expr1; | |
1759 | RefPtr<ExpressionNode> m_expr2; | |
1760 | }; | |
1761 | ||
1762 | class GreaterEqNode : public ExpressionNode { | |
1763 | public: | |
1764 | GreaterEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1765 | : m_expr1(expr1) | |
1766 | , m_expr2(expr2) | |
1767 | { | |
1768 | } | |
1769 | ||
1770 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1771 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1772 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1773 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1774 | virtual Precedence precedence() const { return PrecRelational; } | |
1775 | ||
1776 | private: | |
1777 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
1778 | ||
1779 | RefPtr<ExpressionNode> m_expr1; | |
1780 | RefPtr<ExpressionNode> m_expr2; | |
1781 | }; | |
1782 | ||
1783 | class InstanceOfNode : public ExpressionNode { | |
1784 | public: | |
1785 | InstanceOfNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1786 | : ExpressionNode(BooleanType) | |
1787 | , m_expr1(expr1) | |
1788 | , m_expr2(expr2) | |
1789 | { | |
1790 | } | |
1791 | ||
1792 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1793 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1794 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1795 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1796 | virtual Precedence precedence() const { return PrecRelational; } | |
1797 | ||
1798 | private: | |
1799 | RefPtr<ExpressionNode> m_expr1; | |
1800 | RefPtr<ExpressionNode> m_expr2; | |
1801 | }; | |
1802 | ||
1803 | class InNode : public ExpressionNode { | |
1804 | public: | |
1805 | InNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1806 | : m_expr1(expr1) | |
1807 | , m_expr2(expr2) | |
1808 | { | |
1809 | } | |
1810 | ||
1811 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1812 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1813 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1814 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1815 | virtual Precedence precedence() const { return PrecRelational; } | |
1816 | ||
1817 | private: | |
1818 | RefPtr<ExpressionNode> m_expr1; | |
1819 | RefPtr<ExpressionNode> m_expr2; | |
1820 | }; | |
1821 | ||
1822 | class EqualNode : public ExpressionNode { | |
1823 | public: | |
1824 | EqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1825 | : ExpressionNode(BooleanType) | |
1826 | , m_expr1(expr1) | |
1827 | , m_expr2(expr2) | |
1828 | { | |
1829 | } | |
1830 | ||
1831 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1832 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1833 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1834 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1835 | virtual Precedence precedence() const { return PrecEquality; } | |
1836 | ||
1837 | private: | |
1838 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
1839 | ||
1840 | RefPtr<ExpressionNode> m_expr1; | |
1841 | RefPtr<ExpressionNode> m_expr2; | |
1842 | }; | |
1843 | ||
1844 | class NotEqualNode : public ExpressionNode { | |
1845 | public: | |
1846 | NotEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1847 | : ExpressionNode(BooleanType) | |
1848 | , m_expr1(expr1) | |
1849 | , m_expr2(expr2) | |
1850 | { | |
1851 | } | |
1852 | ||
1853 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1854 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1855 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1856 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1857 | virtual Precedence precedence() const { return PrecEquality; } | |
1858 | ||
1859 | private: | |
1860 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
1861 | ||
1862 | RefPtr<ExpressionNode> m_expr1; | |
1863 | RefPtr<ExpressionNode> m_expr2; | |
1864 | }; | |
1865 | ||
1866 | class StrictEqualNode : public ExpressionNode { | |
1867 | public: | |
1868 | StrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1869 | : ExpressionNode(BooleanType) | |
1870 | , m_expr1(expr1) | |
1871 | , m_expr2(expr2) | |
1872 | { | |
1873 | } | |
1874 | ||
1875 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1876 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1877 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1878 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1879 | virtual Precedence precedence() const { return PrecEquality; } | |
1880 | ||
1881 | private: | |
1882 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
1883 | ||
1884 | RefPtr<ExpressionNode> m_expr1; | |
1885 | RefPtr<ExpressionNode> m_expr2; | |
1886 | }; | |
1887 | ||
1888 | class NotStrictEqualNode : public ExpressionNode { | |
1889 | public: | |
1890 | NotStrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1891 | : ExpressionNode(BooleanType) | |
1892 | , m_expr1(expr1) | |
1893 | , m_expr2(expr2) | |
1894 | { | |
1895 | } | |
1896 | ||
1897 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1898 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1899 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1900 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1901 | virtual Precedence precedence() const { return PrecEquality; } | |
1902 | ||
1903 | private: | |
1904 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
1905 | ||
1906 | RefPtr<ExpressionNode> m_expr1; | |
1907 | RefPtr<ExpressionNode> m_expr2; | |
1908 | }; | |
1909 | ||
1910 | class BitAndNode : public ExpressionNode { | |
1911 | public: | |
1912 | BitAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1913 | : ExpressionNode(NumberType) | |
1914 | , m_expr1(expr1) | |
1915 | , m_expr2(expr2) | |
1916 | { | |
1917 | } | |
1918 | ||
1919 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1920 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1921 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1922 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1923 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1924 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1925 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1926 | virtual Precedence precedence() const { return PrecBitwiseAnd; } | |
1927 | ||
1928 | private: | |
1929 | ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*); | |
1930 | ||
1931 | RefPtr<ExpressionNode> m_expr1; | |
1932 | RefPtr<ExpressionNode> m_expr2; | |
1933 | }; | |
1934 | ||
1935 | class BitOrNode : public ExpressionNode { | |
1936 | public: | |
1937 | BitOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1938 | : ExpressionNode(NumberType) | |
1939 | , m_expr1(expr1) | |
1940 | , m_expr2(expr2) | |
1941 | { | |
1942 | } | |
1943 | ||
1944 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1945 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1946 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1947 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1948 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1949 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1950 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1951 | virtual Precedence precedence() const { return PrecBitwiseOr; } | |
1952 | ||
1953 | private: | |
1954 | ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*); | |
1955 | ||
1956 | RefPtr<ExpressionNode> m_expr1; | |
1957 | RefPtr<ExpressionNode> m_expr2; | |
1958 | }; | |
1959 | ||
1960 | class BitXOrNode : public ExpressionNode { | |
1961 | public: | |
1962 | BitXOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1963 | : ExpressionNode(NumberType) | |
1964 | , m_expr1(expr1) | |
1965 | , m_expr2(expr2) | |
1966 | { | |
1967 | } | |
1968 | ||
1969 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1970 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1971 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
1972 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
1973 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
1974 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
1975 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
1976 | virtual Precedence precedence() const { return PrecBitwiseXor; } | |
1977 | ||
1978 | private: | |
1979 | ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*); | |
1980 | ||
1981 | RefPtr<ExpressionNode> m_expr1; | |
1982 | RefPtr<ExpressionNode> m_expr2; | |
1983 | }; | |
1984 | ||
1985 | /** | |
1986 | * m_expr1 && m_expr2, m_expr1 || m_expr2 | |
1987 | */ | |
1988 | class LogicalAndNode : public ExpressionNode { | |
1989 | public: | |
1990 | LogicalAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
1991 | : ExpressionNode(BooleanType) | |
1992 | , m_expr1(expr1) | |
1993 | , m_expr2(expr2) | |
1994 | { | |
1995 | } | |
1996 | ||
1997 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
1998 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
1999 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
2000 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2001 | virtual Precedence precedence() const { return PrecLogicalAnd; } | |
2002 | ||
2003 | private: | |
2004 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
2005 | ||
2006 | RefPtr<ExpressionNode> m_expr1; | |
2007 | RefPtr<ExpressionNode> m_expr2; | |
2008 | }; | |
2009 | ||
2010 | class LogicalOrNode : public ExpressionNode { | |
2011 | public: | |
2012 | LogicalOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
2013 | : ExpressionNode(BooleanType) | |
2014 | , m_expr1(expr1) | |
2015 | , m_expr2(expr2) | |
2016 | { | |
2017 | } | |
2018 | ||
2019 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2020 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2021 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
2022 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2023 | virtual Precedence precedence() const { return PrecLogicalOr; } | |
2024 | ||
2025 | private: | |
2026 | ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*); | |
2027 | ||
2028 | RefPtr<ExpressionNode> m_expr1; | |
2029 | RefPtr<ExpressionNode> m_expr2; | |
2030 | }; | |
2031 | ||
2032 | /** | |
2033 | * The ternary operator, "m_logical ? m_expr1 : m_expr2" | |
2034 | */ | |
2035 | class ConditionalNode : public ExpressionNode { | |
2036 | public: | |
2037 | ConditionalNode(ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
2038 | : m_logical(logical) | |
2039 | , m_expr1(expr1) | |
2040 | , m_expr2(expr2) | |
2041 | { | |
2042 | } | |
2043 | ||
2044 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2045 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2046 | virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL; | |
2047 | virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL; | |
2048 | virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL; | |
2049 | virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL; | |
2050 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2051 | virtual Precedence precedence() const { return PrecConditional; } | |
2052 | ||
2053 | private: | |
2054 | RefPtr<ExpressionNode> m_logical; | |
2055 | RefPtr<ExpressionNode> m_expr1; | |
2056 | RefPtr<ExpressionNode> m_expr2; | |
2057 | }; | |
2058 | ||
2059 | class ReadModifyResolveNode : public ExpressionNode { | |
2060 | public: | |
2061 | ReadModifyResolveNode(const Identifier& ident, Operator oper, ExpressionNode* right) KJS_FAST_CALL | |
2062 | : m_ident(ident) | |
2063 | , m_operator(oper) | |
2064 | , m_right(right) | |
2065 | { | |
2066 | } | |
2067 | ||
2068 | ReadModifyResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
2069 | : ExpressionNode(PlacementNewAdopt) | |
2070 | , m_ident(PlacementNewAdopt) | |
2071 | , m_right(PlacementNewAdopt) | |
2072 | { | |
2073 | } | |
2074 | ||
2075 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2076 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2077 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2078 | virtual Precedence precedence() const { return PrecAssignment; } | |
2079 | ||
2080 | protected: | |
2081 | Identifier m_ident; | |
2082 | Operator m_operator; | |
2083 | RefPtr<ExpressionNode> m_right; | |
2084 | size_t m_index; // Used by ReadModifyLocalVarNode. | |
2085 | }; | |
2086 | ||
2087 | class ReadModifyLocalVarNode : public ReadModifyResolveNode { | |
2088 | public: | |
2089 | ReadModifyLocalVarNode(size_t i) KJS_FAST_CALL | |
2090 | : ReadModifyResolveNode(PlacementNewAdopt) | |
2091 | { | |
2092 | ASSERT(i != missingSymbolMarker()); | |
2093 | m_index = i; | |
2094 | } | |
2095 | ||
2096 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2097 | }; | |
2098 | ||
2099 | class ReadModifyConstNode : public ReadModifyResolveNode { | |
2100 | public: | |
2101 | ReadModifyConstNode(size_t i) KJS_FAST_CALL | |
2102 | : ReadModifyResolveNode(PlacementNewAdopt) | |
2103 | { | |
2104 | ASSERT(i != missingSymbolMarker()); | |
2105 | m_index = i; | |
2106 | } | |
2107 | ||
2108 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2109 | }; | |
2110 | ||
2111 | class AssignResolveNode : public ExpressionNode { | |
2112 | public: | |
2113 | AssignResolveNode(const Identifier& ident, ExpressionNode* right) KJS_FAST_CALL | |
2114 | : m_ident(ident) | |
2115 | , m_right(right) | |
2116 | { | |
2117 | } | |
2118 | ||
2119 | AssignResolveNode(PlacementNewAdoptType) KJS_FAST_CALL | |
2120 | : ExpressionNode(PlacementNewAdopt) | |
2121 | , m_ident(PlacementNewAdopt) | |
2122 | , m_right(PlacementNewAdopt) | |
2123 | { | |
2124 | } | |
2125 | ||
2126 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2127 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2128 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2129 | virtual Precedence precedence() const { return PrecAssignment; } | |
2130 | ||
2131 | protected: | |
2132 | Identifier m_ident; | |
2133 | RefPtr<ExpressionNode> m_right; | |
2134 | size_t m_index; // Used by ReadModifyLocalVarNode. | |
2135 | }; | |
2136 | ||
2137 | class AssignLocalVarNode : public AssignResolveNode { | |
2138 | public: | |
2139 | AssignLocalVarNode(size_t i) KJS_FAST_CALL | |
2140 | : AssignResolveNode(PlacementNewAdopt) | |
2141 | { | |
2142 | ASSERT(i != missingSymbolMarker()); | |
2143 | m_index = i; | |
2144 | } | |
2145 | ||
2146 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2147 | }; | |
2148 | ||
2149 | class AssignConstNode : public AssignResolveNode { | |
2150 | public: | |
2151 | AssignConstNode() KJS_FAST_CALL | |
2152 | : AssignResolveNode(PlacementNewAdopt) | |
2153 | { | |
2154 | } | |
2155 | ||
2156 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2157 | }; | |
2158 | ||
2159 | class ReadModifyBracketNode : public ExpressionNode { | |
2160 | public: | |
2161 | ReadModifyBracketNode(ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right) KJS_FAST_CALL | |
2162 | : m_base(base) | |
2163 | , m_subscript(subscript) | |
2164 | , m_operator(oper) | |
2165 | , m_right(right) | |
2166 | { | |
2167 | } | |
2168 | ||
2169 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2170 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2171 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2172 | virtual Precedence precedence() const { return PrecAssignment; } | |
2173 | ||
2174 | protected: | |
2175 | RefPtr<ExpressionNode> m_base; | |
2176 | RefPtr<ExpressionNode> m_subscript; | |
2177 | Operator m_operator; | |
2178 | RefPtr<ExpressionNode> m_right; | |
2179 | }; | |
2180 | ||
2181 | class AssignBracketNode : public ExpressionNode { | |
2182 | public: | |
2183 | AssignBracketNode(ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right) KJS_FAST_CALL | |
2184 | : m_base(base) | |
2185 | , m_subscript(subscript) | |
2186 | , m_right(right) | |
2187 | { | |
2188 | } | |
2189 | ||
2190 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2191 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2192 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2193 | virtual Precedence precedence() const { return PrecAssignment; } | |
2194 | ||
2195 | protected: | |
2196 | RefPtr<ExpressionNode> m_base; | |
2197 | RefPtr<ExpressionNode> m_subscript; | |
2198 | RefPtr<ExpressionNode> m_right; | |
2199 | }; | |
2200 | ||
2201 | class AssignDotNode : public ExpressionNode { | |
2202 | public: | |
2203 | AssignDotNode(ExpressionNode* base, const Identifier& ident, ExpressionNode* right) KJS_FAST_CALL | |
2204 | : m_base(base) | |
2205 | , m_ident(ident) | |
2206 | , m_right(right) | |
2207 | { | |
2208 | } | |
2209 | ||
2210 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2211 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2212 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2213 | virtual Precedence precedence() const { return PrecAssignment; } | |
2214 | ||
2215 | protected: | |
2216 | RefPtr<ExpressionNode> m_base; | |
2217 | Identifier m_ident; | |
2218 | RefPtr<ExpressionNode> m_right; | |
2219 | }; | |
2220 | ||
2221 | class ReadModifyDotNode : public ExpressionNode { | |
2222 | public: | |
2223 | ReadModifyDotNode(ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right) KJS_FAST_CALL | |
2224 | : m_base(base) | |
2225 | , m_ident(ident) | |
2226 | , m_operator(oper) | |
2227 | , m_right(right) | |
2228 | { | |
2229 | } | |
2230 | ||
2231 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2232 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2233 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2234 | virtual Precedence precedence() const { return PrecAssignment; } | |
2235 | ||
2236 | protected: | |
2237 | RefPtr<ExpressionNode> m_base; | |
2238 | Identifier m_ident; | |
2239 | Operator m_operator; | |
2240 | RefPtr<ExpressionNode> m_right; | |
2241 | }; | |
2242 | ||
2243 | class AssignErrorNode : public ExpressionNode { | |
2244 | public: | |
2245 | AssignErrorNode(ExpressionNode* left, Operator oper, ExpressionNode* right) KJS_FAST_CALL | |
2246 | : m_left(left) | |
2247 | , m_operator(oper) | |
2248 | , m_right(right) | |
2249 | { | |
2250 | } | |
2251 | ||
2252 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2253 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2254 | virtual Precedence precedence() const { return PrecAssignment; } | |
2255 | ||
2256 | protected: | |
2257 | RefPtr<ExpressionNode> m_left; | |
2258 | Operator m_operator; | |
2259 | RefPtr<ExpressionNode> m_right; | |
2260 | }; | |
2261 | ||
2262 | class CommaNode : public ExpressionNode { | |
2263 | public: | |
2264 | CommaNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
2265 | : m_expr1(expr1) | |
2266 | , m_expr2(expr2) | |
2267 | { | |
2268 | m_expr1->optimizeForUnnecessaryResult(); | |
2269 | } | |
2270 | ||
2271 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2272 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2273 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2274 | virtual Precedence precedence() const { return PrecExpression; } | |
2275 | ||
2276 | private: | |
2277 | RefPtr<ExpressionNode> m_expr1; | |
2278 | RefPtr<ExpressionNode> m_expr2; | |
2279 | }; | |
2280 | ||
2281 | class VarDeclCommaNode : public CommaNode { | |
2282 | public: | |
2283 | VarDeclCommaNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL | |
2284 | : CommaNode(expr1, expr2) | |
2285 | { | |
2286 | } | |
2287 | virtual Precedence precedence() const { return PrecAssignment; } | |
2288 | }; | |
2289 | ||
2290 | class ConstDeclNode : public ExpressionNode { | |
2291 | public: | |
2292 | ConstDeclNode(const Identifier& ident, ExpressionNode* in) KJS_FAST_CALL; | |
2293 | ||
2294 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2295 | virtual KJS::JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2296 | void evaluateSingle(ExecState*) KJS_FAST_CALL; | |
2297 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2298 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
2299 | PassRefPtr<ConstDeclNode> releaseNext() KJS_FAST_CALL { return m_next.release(); } | |
2300 | ||
2301 | Identifier m_ident; | |
2302 | ListRefPtr<ConstDeclNode> m_next; | |
2303 | RefPtr<ExpressionNode> m_init; | |
2304 | ||
2305 | private: | |
2306 | void handleSlowCase(ExecState*, const ScopeChain&, JSValue*) KJS_FAST_CALL NEVER_INLINE; | |
2307 | }; | |
2308 | ||
2309 | class ConstStatementNode : public StatementNode { | |
2310 | public: | |
2311 | ConstStatementNode(ConstDeclNode* next) KJS_FAST_CALL | |
2312 | : m_next(next) | |
2313 | { | |
2314 | } | |
2315 | ||
2316 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2317 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2318 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2319 | ||
2320 | private: | |
2321 | RefPtr<ConstDeclNode> m_next; | |
2322 | }; | |
2323 | ||
2324 | typedef Vector<RefPtr<StatementNode> > StatementVector; | |
2325 | ||
2326 | class SourceElements : public ParserRefCounted { | |
2327 | public: | |
2328 | void append(PassRefPtr<StatementNode>); | |
2329 | void releaseContentsIntoVector(StatementVector& destination) | |
2330 | { | |
2331 | ASSERT(destination.isEmpty()); | |
2332 | m_statements.swap(destination); | |
2333 | } | |
2334 | ||
2335 | private: | |
2336 | StatementVector m_statements; | |
2337 | }; | |
2338 | ||
2339 | class BlockNode : public StatementNode { | |
2340 | public: | |
2341 | BlockNode(SourceElements* children) KJS_FAST_CALL; | |
2342 | ||
2343 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2344 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2345 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2346 | ||
2347 | protected: | |
2348 | StatementVector m_children; | |
2349 | }; | |
2350 | ||
2351 | class EmptyStatementNode : public StatementNode { | |
2352 | public: | |
2353 | EmptyStatementNode() KJS_FAST_CALL // debug | |
2354 | { | |
2355 | } | |
2356 | ||
2357 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2358 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2359 | virtual bool isEmptyStatement() const KJS_FAST_CALL { return true; } | |
2360 | }; | |
2361 | ||
2362 | class ExprStatementNode : public StatementNode { | |
2363 | public: | |
2364 | ExprStatementNode(ExpressionNode* expr) KJS_FAST_CALL | |
2365 | : m_expr(expr) | |
2366 | { | |
2367 | } | |
2368 | ||
2369 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2370 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2371 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2372 | ||
2373 | private: | |
2374 | RefPtr<ExpressionNode> m_expr; | |
2375 | }; | |
2376 | ||
2377 | class VarStatementNode : public StatementNode { | |
2378 | public: | |
2379 | VarStatementNode(ExpressionNode* expr) KJS_FAST_CALL | |
2380 | : m_expr(expr) | |
2381 | { | |
2382 | } | |
2383 | ||
2384 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2385 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2386 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2387 | ||
2388 | private: | |
2389 | RefPtr<ExpressionNode> m_expr; | |
2390 | }; | |
2391 | ||
2392 | class IfNode : public StatementNode { | |
2393 | public: | |
2394 | IfNode(ExpressionNode* condition, StatementNode* ifBlock) KJS_FAST_CALL | |
2395 | : m_condition(condition) | |
2396 | , m_ifBlock(ifBlock) | |
2397 | { | |
2398 | } | |
2399 | ||
2400 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2401 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2402 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2403 | ||
2404 | protected: | |
2405 | RefPtr<ExpressionNode> m_condition; | |
2406 | RefPtr<StatementNode> m_ifBlock; | |
2407 | }; | |
2408 | ||
2409 | class IfElseNode : public IfNode { | |
2410 | public: | |
2411 | IfElseNode(ExpressionNode* condtion, StatementNode* ifBlock, StatementNode* elseBlock) KJS_FAST_CALL | |
2412 | : IfNode(condtion, ifBlock) | |
2413 | , m_elseBlock(elseBlock) | |
2414 | { | |
2415 | } | |
2416 | ||
2417 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2418 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2419 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2420 | ||
2421 | private: | |
2422 | RefPtr<StatementNode> m_elseBlock; | |
2423 | }; | |
2424 | ||
2425 | class DoWhileNode : public StatementNode { | |
2426 | public: | |
2427 | DoWhileNode(StatementNode* statement, ExpressionNode* expr) KJS_FAST_CALL | |
2428 | : m_statement(statement) | |
2429 | , m_expr(expr) | |
2430 | { | |
2431 | } | |
2432 | ||
2433 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2434 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2435 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2436 | ||
2437 | private: | |
2438 | RefPtr<StatementNode> m_statement; | |
2439 | RefPtr<ExpressionNode> m_expr; | |
2440 | }; | |
2441 | ||
2442 | class WhileNode : public StatementNode { | |
2443 | public: | |
2444 | WhileNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL | |
2445 | : m_expr(expr) | |
2446 | , m_statement(statement) | |
2447 | { | |
2448 | } | |
2449 | ||
2450 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2451 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2452 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2453 | ||
2454 | private: | |
2455 | RefPtr<ExpressionNode> m_expr; | |
2456 | RefPtr<StatementNode> m_statement; | |
2457 | }; | |
2458 | ||
2459 | class ForNode : public StatementNode { | |
2460 | public: | |
2461 | ForNode(ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl) KJS_FAST_CALL | |
2462 | : m_expr1(expr1 ? expr1 : new PlaceholderTrueNode) | |
2463 | , m_expr2(expr2 ? expr2 : new PlaceholderTrueNode) | |
2464 | , m_expr3(expr3 ? expr3 : new PlaceholderTrueNode) | |
2465 | , m_statement(statement) | |
2466 | , m_expr1WasVarDecl(expr1 && expr1WasVarDecl) | |
2467 | { | |
2468 | ASSERT(m_expr1); | |
2469 | ASSERT(m_expr2); | |
2470 | ASSERT(m_expr3); | |
2471 | ASSERT(statement); | |
2472 | ||
2473 | m_expr1->optimizeForUnnecessaryResult(); | |
2474 | m_expr3->optimizeForUnnecessaryResult(); | |
2475 | } | |
2476 | ||
2477 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2478 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2479 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2480 | ||
2481 | private: | |
2482 | RefPtr<ExpressionNode> m_expr1; | |
2483 | RefPtr<ExpressionNode> m_expr2; | |
2484 | RefPtr<ExpressionNode> m_expr3; | |
2485 | RefPtr<StatementNode> m_statement; | |
2486 | bool m_expr1WasVarDecl; | |
2487 | }; | |
2488 | ||
2489 | class ForInNode : public StatementNode { | |
2490 | public: | |
2491 | ForInNode(ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL; | |
2492 | ForInNode(const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL; | |
2493 | ||
2494 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2495 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2496 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2497 | ||
2498 | private: | |
2499 | Identifier m_ident; | |
2500 | RefPtr<ExpressionNode> m_init; | |
2501 | RefPtr<ExpressionNode> m_lexpr; | |
2502 | RefPtr<ExpressionNode> m_expr; | |
2503 | RefPtr<StatementNode> m_statement; | |
2504 | bool m_identIsVarDecl; | |
2505 | }; | |
2506 | ||
2507 | class ContinueNode : public StatementNode { | |
2508 | public: | |
2509 | ContinueNode() KJS_FAST_CALL | |
2510 | { | |
2511 | } | |
2512 | ||
2513 | ContinueNode(const Identifier& ident) KJS_FAST_CALL | |
2514 | : m_ident(ident) | |
2515 | { | |
2516 | } | |
2517 | ||
2518 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2519 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2520 | ||
2521 | private: | |
2522 | Identifier m_ident; | |
2523 | }; | |
2524 | ||
2525 | class BreakNode : public StatementNode { | |
2526 | public: | |
2527 | BreakNode() KJS_FAST_CALL | |
2528 | { | |
2529 | } | |
2530 | ||
2531 | BreakNode(const Identifier& ident) KJS_FAST_CALL | |
2532 | : m_ident(ident) | |
2533 | { | |
2534 | } | |
2535 | ||
2536 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2537 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2538 | ||
2539 | private: | |
2540 | Identifier m_ident; | |
2541 | }; | |
2542 | ||
2543 | class ReturnNode : public StatementNode { | |
2544 | public: | |
2545 | ReturnNode(ExpressionNode* value) KJS_FAST_CALL | |
2546 | : m_value(value) | |
2547 | { | |
2548 | } | |
2549 | ||
2550 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2551 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2552 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2553 | ||
2554 | private: | |
2555 | RefPtr<ExpressionNode> m_value; | |
2556 | }; | |
2557 | ||
2558 | class WithNode : public StatementNode { | |
2559 | public: | |
2560 | WithNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL | |
2561 | : m_expr(expr) | |
2562 | , m_statement(statement) | |
2563 | { | |
2564 | } | |
2565 | ||
2566 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2567 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2568 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2569 | ||
2570 | private: | |
2571 | RefPtr<ExpressionNode> m_expr; | |
2572 | RefPtr<StatementNode> m_statement; | |
2573 | }; | |
2574 | ||
2575 | class LabelNode : public StatementNode { | |
2576 | public: | |
2577 | LabelNode(const Identifier& label, StatementNode* statement) KJS_FAST_CALL | |
2578 | : m_label(label) | |
2579 | , m_statement(statement) | |
2580 | { | |
2581 | } | |
2582 | ||
2583 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2584 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2585 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2586 | ||
2587 | private: | |
2588 | Identifier m_label; | |
2589 | RefPtr<StatementNode> m_statement; | |
2590 | }; | |
2591 | ||
2592 | class ThrowNode : public StatementNode { | |
2593 | public: | |
2594 | ThrowNode(ExpressionNode* expr) KJS_FAST_CALL | |
2595 | : m_expr(expr) | |
2596 | { | |
2597 | } | |
2598 | ||
2599 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2600 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2601 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2602 | ||
2603 | private: | |
2604 | RefPtr<ExpressionNode> m_expr; | |
2605 | }; | |
2606 | ||
2607 | class TryNode : public StatementNode { | |
2608 | public: | |
2609 | TryNode(StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock) KJS_FAST_CALL | |
2610 | : m_tryBlock(tryBlock) | |
2611 | , m_exceptionIdent(exceptionIdent) | |
2612 | , m_catchBlock(catchBlock) | |
2613 | , m_finallyBlock(finallyBlock) | |
2614 | { | |
2615 | } | |
2616 | ||
2617 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2618 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2619 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2620 | ||
2621 | private: | |
2622 | RefPtr<StatementNode> m_tryBlock; | |
2623 | Identifier m_exceptionIdent; | |
2624 | RefPtr<StatementNode> m_catchBlock; | |
2625 | RefPtr<StatementNode> m_finallyBlock; | |
2626 | }; | |
2627 | ||
2628 | class ParameterNode : public Node { | |
2629 | public: | |
2630 | ParameterNode(const Identifier& ident) KJS_FAST_CALL | |
2631 | : m_ident(ident) | |
2632 | { | |
2633 | } | |
2634 | ||
2635 | ParameterNode(ParameterNode* l, const Identifier& ident) KJS_FAST_CALL | |
2636 | : m_ident(ident) | |
2637 | { | |
2638 | l->m_next = this; | |
2639 | } | |
2640 | ||
2641 | Identifier ident() KJS_FAST_CALL { return m_ident; } | |
2642 | ParameterNode *nextParam() KJS_FAST_CALL { return m_next.get(); } | |
2643 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2644 | PassRefPtr<ParameterNode> releaseNext() KJS_FAST_CALL { return m_next.release(); } | |
2645 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
2646 | ||
2647 | private: | |
2648 | friend class FuncDeclNode; | |
2649 | friend class FuncExprNode; | |
2650 | Identifier m_ident; | |
2651 | ListRefPtr<ParameterNode> m_next; | |
2652 | }; | |
2653 | ||
2654 | class ScopeNode : public BlockNode { | |
2655 | public: | |
2656 | ScopeNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL; | |
2657 | ||
2658 | int sourceId() const KJS_FAST_CALL { return m_sourceId; } | |
2659 | const UString& sourceURL() const KJS_FAST_CALL { return m_sourceURL; } | |
2660 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2661 | ||
2662 | protected: | |
2663 | void optimizeVariableAccess(ExecState*) KJS_FAST_CALL; | |
2664 | ||
2665 | VarStack m_varStack; | |
2666 | FunctionStack m_functionStack; | |
2667 | ||
2668 | private: | |
2669 | UString m_sourceURL; | |
2670 | int m_sourceId; | |
2671 | }; | |
2672 | ||
2673 | class ProgramNode : public ScopeNode { | |
2674 | public: | |
2675 | static ProgramNode* create(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL; | |
2676 | ||
2677 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2678 | ||
2679 | private: | |
2680 | ProgramNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL; | |
2681 | ||
2682 | void initializeSymbolTable(ExecState*) KJS_FAST_CALL; | |
2683 | ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL; | |
2684 | ||
2685 | Vector<size_t> m_varIndexes; // Storage indexes belonging to the nodes in m_varStack. (Recorded to avoid double lookup.) | |
2686 | Vector<size_t> m_functionIndexes; // Storage indexes belonging to the nodes in m_functionStack. (Recorded to avoid double lookup.) | |
2687 | }; | |
2688 | ||
2689 | class EvalNode : public ScopeNode { | |
2690 | public: | |
2691 | static EvalNode* create(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL; | |
2692 | ||
2693 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2694 | ||
2695 | private: | |
2696 | EvalNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL; | |
2697 | ||
2698 | ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL; | |
2699 | }; | |
2700 | ||
2701 | class FunctionBodyNode : public ScopeNode { | |
2702 | public: | |
2703 | static FunctionBodyNode* create(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL; | |
2704 | ||
2705 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2706 | ||
2707 | SymbolTable& symbolTable() KJS_FAST_CALL { return m_symbolTable; } | |
2708 | ||
2709 | Vector<Identifier>& parameters() KJS_FAST_CALL { return m_parameters; } | |
2710 | UString paramString() const KJS_FAST_CALL; | |
2711 | ||
2712 | protected: | |
2713 | FunctionBodyNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL; | |
2714 | ||
2715 | private: | |
2716 | void initializeSymbolTable(ExecState*) KJS_FAST_CALL; | |
2717 | ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL; | |
2718 | ||
2719 | bool m_initialized; | |
2720 | Vector<Identifier> m_parameters; | |
2721 | SymbolTable m_symbolTable; | |
2722 | }; | |
2723 | ||
2724 | class FuncExprNode : public ExpressionNode { | |
2725 | public: | |
2726 | FuncExprNode(const Identifier& ident, FunctionBodyNode* body, ParameterNode* parameter = 0) KJS_FAST_CALL | |
2727 | : m_ident(ident) | |
2728 | , m_parameter(parameter) | |
2729 | , m_body(body) | |
2730 | { | |
2731 | addParams(); | |
2732 | } | |
2733 | ||
2734 | virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2735 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2736 | virtual Precedence precedence() const { return PrecMember; } | |
2737 | virtual bool needsParensIfLeftmost() const { return true; } | |
2738 | ||
2739 | private: | |
2740 | void addParams() KJS_FAST_CALL; | |
2741 | ||
2742 | // Used for streamTo | |
2743 | friend class PropertyNode; | |
2744 | Identifier m_ident; | |
2745 | RefPtr<ParameterNode> m_parameter; | |
2746 | RefPtr<FunctionBodyNode> m_body; | |
2747 | }; | |
2748 | ||
2749 | class FuncDeclNode : public StatementNode { | |
2750 | public: | |
2751 | FuncDeclNode(const Identifier& ident, FunctionBodyNode* body) KJS_FAST_CALL | |
2752 | : m_ident(ident) | |
2753 | , m_body(body) | |
2754 | { | |
2755 | addParams(); | |
2756 | } | |
2757 | ||
2758 | FuncDeclNode(const Identifier& ident, ParameterNode* parameter, FunctionBodyNode* body) KJS_FAST_CALL | |
2759 | : m_ident(ident) | |
2760 | , m_parameter(parameter) | |
2761 | , m_body(body) | |
2762 | { | |
2763 | addParams(); | |
2764 | } | |
2765 | ||
2766 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2767 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2768 | ALWAYS_INLINE FunctionImp* makeFunction(ExecState*) KJS_FAST_CALL; | |
2769 | ||
2770 | Identifier m_ident; | |
2771 | ||
2772 | private: | |
2773 | void addParams() KJS_FAST_CALL; | |
2774 | ||
2775 | RefPtr<ParameterNode> m_parameter; | |
2776 | RefPtr<FunctionBodyNode> m_body; | |
2777 | }; | |
2778 | ||
2779 | class CaseClauseNode : public Node { | |
2780 | public: | |
2781 | CaseClauseNode(ExpressionNode* expr) KJS_FAST_CALL | |
2782 | : m_expr(expr) | |
2783 | { | |
2784 | } | |
2785 | ||
2786 | CaseClauseNode(ExpressionNode* expr, SourceElements* children) KJS_FAST_CALL | |
2787 | : m_expr(expr) | |
2788 | { | |
2789 | if (children) | |
2790 | children->releaseContentsIntoVector(m_children); | |
2791 | } | |
2792 | ||
2793 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2794 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2795 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
2796 | ||
2797 | JSValue* evaluate(ExecState*) KJS_FAST_CALL; | |
2798 | JSValue* executeStatements(ExecState*) KJS_FAST_CALL; | |
2799 | ||
2800 | private: | |
2801 | RefPtr<ExpressionNode> m_expr; | |
2802 | StatementVector m_children; | |
2803 | }; | |
2804 | ||
2805 | class ClauseListNode : public Node { | |
2806 | public: | |
2807 | ClauseListNode(CaseClauseNode* clause) KJS_FAST_CALL | |
2808 | : m_clause(clause) | |
2809 | { | |
2810 | } | |
2811 | ||
2812 | ClauseListNode(ClauseListNode* clauseList, CaseClauseNode* clause) KJS_FAST_CALL | |
2813 | : m_clause(clause) | |
2814 | { | |
2815 | clauseList->m_next = this; | |
2816 | } | |
2817 | ||
2818 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2819 | CaseClauseNode* getClause() const KJS_FAST_CALL { return m_clause.get(); } | |
2820 | ClauseListNode* getNext() const KJS_FAST_CALL { return m_next.get(); } | |
2821 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2822 | PassRefPtr<ClauseListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); } | |
2823 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
2824 | ||
2825 | private: | |
2826 | friend class CaseBlockNode; | |
2827 | RefPtr<CaseClauseNode> m_clause; | |
2828 | ListRefPtr<ClauseListNode> m_next; | |
2829 | }; | |
2830 | ||
2831 | class CaseBlockNode : public Node { | |
2832 | public: | |
2833 | CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2) KJS_FAST_CALL; | |
2834 | ||
2835 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2836 | JSValue* executeBlock(ExecState*, JSValue *input) KJS_FAST_CALL; | |
2837 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2838 | virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; } | |
2839 | ||
2840 | private: | |
2841 | RefPtr<ClauseListNode> m_list1; | |
2842 | RefPtr<CaseClauseNode> m_defaultClause; | |
2843 | RefPtr<ClauseListNode> m_list2; | |
2844 | }; | |
2845 | ||
2846 | class SwitchNode : public StatementNode { | |
2847 | public: | |
2848 | SwitchNode(ExpressionNode* expr, CaseBlockNode* block) KJS_FAST_CALL | |
2849 | : m_expr(expr) | |
2850 | , m_block(block) | |
2851 | { | |
2852 | } | |
2853 | ||
2854 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2855 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2856 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2857 | ||
2858 | private: | |
2859 | RefPtr<ExpressionNode> m_expr; | |
2860 | RefPtr<CaseBlockNode> m_block; | |
2861 | }; | |
2862 | ||
2863 | class BreakpointCheckStatement : public StatementNode { | |
2864 | public: | |
2865 | BreakpointCheckStatement(PassRefPtr<StatementNode>) KJS_FAST_CALL; | |
2866 | ||
2867 | virtual JSValue* execute(ExecState*) KJS_FAST_CALL; | |
2868 | virtual void streamTo(SourceStream&) const KJS_FAST_CALL; | |
2869 | virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL; | |
2870 | ||
2871 | private: | |
2872 | RefPtr<StatementNode> m_statement; | |
2873 | }; | |
2874 | ||
2875 | struct ElementList { | |
2876 | ElementNode* head; | |
2877 | ElementNode* tail; | |
2878 | }; | |
2879 | ||
2880 | struct PropertyList { | |
2881 | PropertyListNode* head; | |
2882 | PropertyListNode* tail; | |
2883 | }; | |
2884 | ||
2885 | struct ArgumentList { | |
2886 | ArgumentListNode* head; | |
2887 | ArgumentListNode* tail; | |
2888 | }; | |
2889 | ||
2890 | struct ConstDeclList { | |
2891 | ConstDeclNode* head; | |
2892 | ConstDeclNode* tail; | |
2893 | }; | |
2894 | ||
2895 | struct ParameterList { | |
2896 | ParameterNode* head; | |
2897 | ParameterNode* tail; | |
2898 | }; | |
2899 | ||
2900 | struct ClauseList { | |
2901 | ClauseListNode* head; | |
2902 | ClauseListNode* tail; | |
2903 | }; | |
2904 | ||
2905 | } // namespace KJS | |
2906 | ||
2907 | #endif // NODES_H_ |