Context Navigation

source: webkit/trunk/JavaScriptCore/kjs/nodes.h@ 34424

Visit:

Last change on this file since 34424 was 34373, checked in by [email protected], 17 years ago

2008-06-05 Cameron Zwarich <[email protected]>

Reviewed by Maciej.

Bug 19400: subscript operator does not protect base when necessary
<https://bugs.webkit.org/show_bug.cgi?id=19400>

Use a temporary for the base in BracketAccessorNode if the subscript
might possibly modify it.

JavaScriptCore:

kjs/grammar.y:
kjs/nodes.cpp: (KJS::BracketAccessorNode::emitCode):
kjs/nodes.h: (KJS::BracketAccessorNode::):

LayoutTests:

fast/js/codegen-temporaries-expected.txt:
fast/js/resources/codegen-temporaries.js:

Property svn:eol-style set to native

File size: 77.6 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: