Context Navigation

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

Visit:

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

Reviewed by Darin.

Prepare JavaScript heap for being per-thread.

Property svn:eol-style set to native

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

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

Download in other formats: