00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
#ifndef _NODES_H_
00026
#define _NODES_H_
00027
00028
#include "internal.h"
00029
00030
#ifndef NDEBUG
00031
#include <list>
00032
#include <assert.h>
00033
#endif
00034
00035
namespace KJS {
00036
00037
class RegExp;
00038
class SourceElementsNode;
00039
class ObjectLiteralNode;
00040
class PropertyNode;
00041
class SourceStream;
00042
class PropertyValueNode;
00043
class PropertyNode;
00044
00045
enum Operator { OpEqual,
00046 OpEqEq,
00047 OpNotEq,
00048 OpStrEq,
00049 OpStrNEq,
00050 OpPlusEq,
00051 OpMinusEq,
00052 OpMultEq,
00053 OpDivEq,
00054 OpPlusPlus,
00055 OpMinusMinus,
00056 OpLess,
00057 OpLessEq,
00058 OpGreater,
00059 OpGreaterEq,
00060 OpAndEq,
00061 OpXOrEq,
00062 OpOrEq,
00063 OpModEq,
00064 OpAnd,
00065 OpOr,
00066 OpBitAnd,
00067 OpBitXOr,
00068 OpBitOr,
00069 OpLShift,
00070 OpRShift,
00071 OpURShift,
00072 OpIn,
00073 OpInstanceOf
00074 };
00075
00076
class Node {
00077
public:
00078 Node();
00079
virtual ~Node();
00080
00081
00082
virtual Type type()
const {
return UnspecifiedType; }
00083
00087
virtual Reference evaluateReference(
ExecState *exec)
const;
00091
virtual Value evaluate(
ExecState *exec)
const;
00092
virtual bool toBoolean(
ExecState *exec)
const;
00093
virtual double toNumber(
ExecState *exec)
const;
00094
virtual UString toString(
ExecState *exec)
const;
00095
00096
UString toCode() const;
00097 virtual
void streamTo(SourceStream &s) const = 0;
00098 virtual
void processVarDecls(
ExecState* ) {}
00099
int lineNo()
const {
return line; }
00100
00101
public:
00102
00103
virtual void ref() { refcount++; }
00104
#ifdef KJS_DEBUG_MEM
00105
virtual bool deref() { assert( refcount > 0 );
return (!--refcount); }
00106
#else
00107
virtual bool deref() {
return (!--refcount); }
00108
#endif
00109
00110
00111
#ifdef KJS_DEBUG_MEM
00112
static void finalCheck();
00113
#endif
00114
protected:
00115
Value throwError(
ExecState *exec, ErrorType e,
const char *msg)
const;
00116
Value throwError(
ExecState *exec, ErrorType e,
const char *msg,
Value v, Node *expr)
const;
00117
Value throwError(
ExecState *exec, ErrorType e,
const char *msg, Identifier label)
const;
00118
int line;
00119
unsigned int refcount;
00120
virtual int sourceId()
const {
return -1; }
00121
private:
00122
#ifdef KJS_DEBUG_MEM
00123
00124
static std::list<Node *> *s_nodes;
00125
#endif
00126
00127 Node& operator=(
const Node&);
00128 Node(
const Node &other);
00129 };
00130
00131
class StatementNode :
public Node {
00132
public:
00133 StatementNode();
00134
virtual ~StatementNode();
00135
void setLoc(
int line0,
int line1, SourceCode *src);
00136
int firstLine()
const {
return l0; }
00137
int lastLine()
const {
return l1; }
00138
int sourceId()
const {
return sourceCode->sid; }
00139 SourceCode *code()
const {
return sourceCode; }
00140
bool hitStatement(
ExecState *exec);
00141
bool abortStatement(
ExecState *exec);
00142
virtual Completion execute(
ExecState *exec) = 0;
00143
void pushLabel(
const Identifier &
id) { ls.push(
id); }
00144
virtual void processFuncDecl(
ExecState *exec);
00145
protected:
00146
LabelStack ls;
00147
private:
00148 Reference evaluateReference(
ExecState* )
const {
return Reference(0,Identifier::null()); }
00149
int l0, l1;
00150 SourceCode *sourceCode;
00151
bool breakPoint;
00152 };
00153
00154
class NullNode :
public Node {
00155
public:
00156 NullNode() {}
00157
virtual Value evaluate(
ExecState *exec)
const;
00158
virtual bool toBoolean(
ExecState *exec)
const;
00159
virtual double toNumber(
ExecState *exec)
const;
00160
virtual UString toString(
ExecState *exec)
const;
00161
virtual void streamTo(SourceStream &s)
const;
00162 };
00163
00164
class BooleanNode :
public Node {
00165
public:
00166 BooleanNode(
bool v) : val(v) {}
00167
virtual Type type()
const {
return BooleanType; }
00168
virtual Value evaluate(
ExecState *exec)
const;
00169
virtual bool toBoolean(
ExecState *exec)
const;
00170
virtual double toNumber(
ExecState *exec)
const;
00171
virtual UString toString(
ExecState *exec)
const;
00172
virtual void streamTo(SourceStream &s)
const;
00173
private:
00174
bool val;
00175 };
00176
00177
class NumberNode :
public Node {
00178
public:
00179 NumberNode(
double v) : val(v) { }
00180
virtual Type type()
const {
return NumberType; }
00181
virtual Value evaluate(
ExecState *exec)
const;
00182
virtual bool toBoolean(
ExecState *exec)
const;
00183
virtual double toNumber(
ExecState *exec)
const;
00184
virtual UString toString(
ExecState *exec)
const;
00185
virtual void streamTo(SourceStream &s)
const;
00186
private:
00187
double val;
00188 };
00189
00190
class StringNode :
public Node {
00191
public:
00192 StringNode(
const UString *v) : val(*v) { }
00193
virtual Type type()
const {
return StringType; }
00194
virtual Value evaluate(
ExecState *exec)
const;
00195
virtual bool toBoolean(
ExecState *exec)
const;
00196
virtual double toNumber(
ExecState *exec)
const;
00197
virtual UString toString(
ExecState *exec)
const;
00198
virtual void streamTo(SourceStream &s)
const;
00199
private:
00200
UString val;
00201 };
00202
00203
class RegExpNode :
public Node {
00204
public:
00205 RegExpNode(
const UString &p,
const UString &f)
00206 : pattern(p), flags(f) { }
00207
virtual Value evaluate(
ExecState *exec)
const;
00208
virtual bool toBoolean(
ExecState *exec)
const;
00209
virtual void streamTo(SourceStream &s)
const;
00210
private:
00211
UString pattern, flags;
00212 };
00213
00214
class ThisNode :
public Node {
00215
public:
00216 ThisNode() {}
00217
virtual Value evaluate(
ExecState *exec)
const;
00218
virtual void streamTo(SourceStream &s)
const;
00219 };
00220
00221
class ResolveNode :
public Node {
00222
public:
00223 ResolveNode(
const Identifier &s) : ident(s) { }
00224 Reference evaluateReference(
ExecState *exec)
const;
00225
virtual Value evaluate(
ExecState *exec)
const;
00226
virtual void streamTo(SourceStream &s)
const;
00227
private:
00228 Identifier ident;
00229 };
00230
00231
class GroupNode :
public Node {
00232
public:
00233 GroupNode(Node *g) : group(g) { }
00234
virtual void ref();
00235
virtual bool deref();
00236 Reference evaluateReference(
ExecState *exec)
const;
00237
virtual Value evaluate(
ExecState *exec)
const;
00238
virtual void streamTo(SourceStream &s)
const;
00239
private:
00240 Node *group;
00241 };
00242
00243
class ElementNode :
public Node {
00244
public:
00245
00246 ElementNode(
int e, Node *n) : list(this), elision(e), node(n) { }
00247 ElementNode(ElementNode *l,
int e, Node *n)
00248 : list(l->list), elision(e), node(n) { l->list =
this; }
00249
virtual void ref();
00250
virtual bool deref();
00251
virtual Value evaluate(
ExecState *exec)
const;
00252
virtual void streamTo(SourceStream &s)
const;
00253
private:
00254
friend class ArrayNode;
00255 ElementNode *list;
00256
int elision;
00257 Node *node;
00258 };
00259
00260
class ArrayNode :
public Node {
00261
public:
00262 ArrayNode(
int e) : element(0L), elision(e), opt(true) { }
00263 ArrayNode(ElementNode *ele)
00264 : element(ele->list), elision(0), opt(false) { ele->list = 0; }
00265 ArrayNode(
int eli, ElementNode *ele)
00266 : element(ele->list), elision(eli), opt(true) { ele->list = 0; }
00267
virtual void ref();
00268
virtual bool deref();
00269
virtual Value evaluate(
ExecState *exec)
const;
00270
virtual void streamTo(SourceStream &s)
const;
00271
private:
00272 ElementNode *element;
00273
int elision;
00274
bool opt;
00275 };
00276
00277
class PropertyValueNode :
public Node {
00278
public:
00279
00280 PropertyValueNode(PropertyNode *n, Node *a)
00281 :
name(n), assign(a), list(this) { }
00282 PropertyValueNode(PropertyNode *n, Node *a, PropertyValueNode *l)
00283 :
name(n), assign(a), list(l->list) { l->list =
this; }
00284
virtual void ref();
00285
virtual bool deref();
00286
virtual Value evaluate(
ExecState *exec)
const;
00287
virtual void streamTo(SourceStream &s)
const;
00288
private:
00289
friend class ObjectLiteralNode;
00290 PropertyNode *
name;
00291 Node *assign;
00292 PropertyValueNode *list;
00293 };
00294
00295
class PropertyNode :
public Node {
00296
public:
00297 PropertyNode(
double d) : numeric(d) { }
00298 PropertyNode(
const Identifier &s) : str(s) { }
00299
virtual Value evaluate(
ExecState *exec)
const;
00300
virtual void streamTo(SourceStream &s)
const;
00301
private:
00302
double numeric;
00303 Identifier str;
00304 };
00305
00306
class ObjectLiteralNode :
public Node {
00307
public:
00308
00309 ObjectLiteralNode() : list(0) { }
00310
00311 ObjectLiteralNode(PropertyValueNode *l) : list(l->list) { l->list = 0; }
00312
virtual void ref();
00313
virtual bool deref();
00314
virtual Value evaluate(
ExecState *exec)
const;
00315
virtual void streamTo(SourceStream &s)
const;
00316
private:
00317 PropertyValueNode *list;
00318 };
00319
00320
class AccessorNode1 :
public Node {
00321
public:
00322 AccessorNode1(Node *e1, Node *e2) : expr1(e1), expr2(e2) {}
00323
virtual void ref();
00324
virtual bool deref();
00325 Reference evaluateReference(
ExecState *exec)
const;
00326
virtual void streamTo(SourceStream &s)
const;
00327
private:
00328 Node *expr1;
00329 Node *expr2;
00330 };
00331
00332
class AccessorNode2 :
public Node {
00333
public:
00334 AccessorNode2(Node *e,
const Identifier &s) : expr(e), ident(s) { }
00335
virtual void ref();
00336
virtual bool deref();
00337 Reference evaluateReference(
ExecState *exec)
const;
00338
virtual void streamTo(SourceStream &s)
const;
00339
private:
00340 Node *expr;
00341 Identifier ident;
00342 };
00343
00344
class ArgumentListNode :
public Node {
00345
public:
00346
00347 ArgumentListNode(Node *e) : list(this), expr(e) {}
00348 ArgumentListNode(ArgumentListNode *l, Node *e)
00349 : list(l->list), expr(e) { l->list =
this; }
00350
virtual void ref();
00351
virtual bool deref();
00352
virtual Value evaluate(
ExecState *exec)
const;
00353
List evaluateList(
ExecState *exec)
const;
00354
virtual void streamTo(SourceStream &s)
const;
00355
private:
00356
friend class ArgumentsNode;
00357 ArgumentListNode *list;
00358 Node *expr;
00359 };
00360
00361
class ArgumentsNode :
public Node {
00362
public:
00363 ArgumentsNode() : list(0) {}
00364 ArgumentsNode(ArgumentListNode *l) : list(l->list) { l->list = 0; }
00365
virtual void ref();
00366
virtual bool deref();
00367
virtual Value evaluate(
ExecState *exec)
const;
00368
List evaluateList(
ExecState *exec)
const;
00369
virtual void streamTo(SourceStream &s)
const;
00370
private:
00371 ArgumentListNode *list;
00372 };
00373
00374
class NewExprNode :
public Node {
00375
public:
00376 NewExprNode(Node *e) : expr(e), args(0L) {}
00377 NewExprNode(Node *e, ArgumentsNode *a) : expr(e), args(a) {}
00378
virtual void ref();
00379
virtual bool deref();
00380
virtual Value evaluate(
ExecState *exec)
const;
00381
virtual void streamTo(SourceStream &s)
const;
00382
private:
00383 Node *expr;
00384 ArgumentsNode *args;
00385 };
00386
00387
class FunctionCallNode :
public Node {
00388
public:
00389 FunctionCallNode(Node *e, ArgumentsNode *a) : expr(e), args(a) {}
00390
virtual void ref();
00391
virtual bool deref();
00392
virtual Value evaluate(
ExecState *exec)
const;
00393
virtual void streamTo(SourceStream &s)
const;
00394
private:
00395 Node *expr;
00396 ArgumentsNode *args;
00397 };
00398
00399
class PostfixNode :
public Node {
00400
public:
00401 PostfixNode(Node *e, Operator o) : expr(e), oper(o) {}
00402
virtual void ref();
00403
virtual bool deref();
00404
virtual Value evaluate(
ExecState *exec)
const;
00405
virtual void streamTo(SourceStream &s)
const;
00406
private:
00407 Node *expr;
00408 Operator oper;
00409 };
00410
00411
class DeleteNode :
public Node {
00412
public:
00413 DeleteNode(Node *e) : expr(e) {}
00414
virtual void ref();
00415
virtual bool deref();
00416
virtual Value evaluate(
ExecState *exec)
const;
00417
virtual void streamTo(SourceStream &s)
const;
00418
private:
00419 Node *expr;
00420 };
00421
00422
class VoidNode :
public Node {
00423
public:
00424 VoidNode(Node *e) : expr(e) {}
00425
virtual void ref();
00426
virtual bool deref();
00427
virtual Value evaluate(
ExecState *exec)
const;
00428
virtual void streamTo(SourceStream &s)
const;
00429
private:
00430 Node *expr;
00431 };
00432
00433
class TypeOfNode :
public Node {
00434
public:
00435 TypeOfNode(Node *e) : expr(e) {}
00436
virtual void ref();
00437
virtual bool deref();
00438
virtual Value evaluate(
ExecState *exec)
const;
00439
virtual void streamTo(SourceStream &s)
const;
00440
private:
00441 Node *expr;
00442 };
00443
00444
class PrefixNode :
public Node {
00445
public:
00446 PrefixNode(Operator o, Node *e) : oper(o), expr(e) {}
00447
virtual void ref();
00448
virtual bool deref();
00449
virtual Value evaluate(
ExecState *exec)
const;
00450
virtual void streamTo(SourceStream &s)
const;
00451
private:
00452 Operator oper;
00453 Node *expr;
00454 };
00455
00456
class UnaryPlusNode :
public Node {
00457
public:
00458 UnaryPlusNode(Node *e) : expr(e) {}
00459
virtual void ref();
00460
virtual bool deref();
00461
virtual Value evaluate(
ExecState *exec)
const;
00462
virtual double toNumber(
ExecState *exec)
const;
00463
virtual void streamTo(SourceStream &s)
const;
00464
private:
00465 Node *expr;
00466 };
00467
00468
class NegateNode :
public Node {
00469
public:
00470 NegateNode(Node *e) : expr(e) {}
00471
virtual void ref();
00472
virtual bool deref();
00473
virtual Value evaluate(
ExecState *exec)
const;
00474
virtual double toNumber(
ExecState *exec)
const;
00475
virtual void streamTo(SourceStream &s)
const;
00476
private:
00477 Node *expr;
00478 };
00479
00480
class BitwiseNotNode :
public Node {
00481
public:
00482 BitwiseNotNode(Node *e) : expr(e) {}
00483
virtual void ref();
00484
virtual bool deref();
00485
virtual Value evaluate(
ExecState *exec)
const;
00486
virtual void streamTo(SourceStream &s)
const;
00487
private:
00488 Node *expr;
00489 };
00490
00491
class LogicalNotNode :
public Node {
00492
public:
00493 LogicalNotNode(Node *e) : expr(e) {}
00494
virtual void ref();
00495
virtual bool deref();
00496
virtual Value evaluate(
ExecState *exec)
const;
00497
virtual bool toBoolean(
ExecState *exec)
const;
00498
virtual void streamTo(SourceStream &s)
const;
00499
private:
00500 Node *expr;
00501 };
00502
00503
class MultNode :
public Node {
00504
public:
00505 MultNode(Node *t1, Node *t2,
char op) : term1(t1), term2(t2), oper(op) {}
00506
virtual void ref();
00507
virtual bool deref();
00508
virtual Value evaluate(
ExecState *exec)
const;
00509
virtual void streamTo(SourceStream &s)
const;
00510
private:
00511 Node *term1, *term2;
00512
char oper;
00513 };
00514
00515
class AddNode :
public Node {
00516
public:
00517 AddNode(Node *t1, Node *t2,
char op) : term1(t1), term2(t2), oper(op) {}
00518
00519
static Node* create(Node *t1, Node *t2,
char op);
00520
00521
virtual void ref();
00522
virtual bool deref();
00523
virtual Value evaluate(
ExecState *exec)
const;
00524
virtual void streamTo(SourceStream &s)
const;
00525
private:
00526 Node *term1, *term2;
00527
char oper;
00528 };
00529
00530
class AppendStringNode :
public Node {
00531
public:
00532 AppendStringNode(Node *t,
const UString &s) : term(t), str(s) { }
00533
virtual void ref();
00534
virtual bool deref();
00535
virtual Value evaluate(
ExecState *exec)
const;
00536
virtual void streamTo(SourceStream &s)
const;
00537
private:
00538 Node *term;
00539
UString str;
00540 };
00541
00542
class ShiftNode :
public Node {
00543
public:
00544 ShiftNode(Node *t1, Operator o, Node *t2)
00545 : term1(t1), term2(t2), oper(o) {}
00546
virtual void ref();
00547
virtual bool deref();
00548
virtual Value evaluate(
ExecState *exec)
const;
00549
virtual void streamTo(SourceStream &s)
const;
00550
private:
00551 Node *term1, *term2;
00552 Operator oper;
00553 };
00554
00555
class RelationalNode :
public Node {
00556
public:
00557 RelationalNode(Node *e1, Operator o, Node *e2) :
00558 expr1(e1), expr2(e2), oper(o) {}
00559
virtual void ref();
00560
virtual bool deref();
00561
virtual Value evaluate(
ExecState *exec)
const;
00562
virtual void streamTo(SourceStream &s)
const;
00563
private:
00564 Node *expr1, *expr2;
00565 Operator oper;
00566 };
00567
00568
class EqualNode :
public Node {
00569
public:
00570 EqualNode(Node *e1, Operator o, Node *e2)
00571 : expr1(e1), expr2(e2), oper(o) {}
00572
virtual void ref();
00573
virtual bool deref();
00574
virtual Value evaluate(
ExecState *exec)
const;
00575
virtual void streamTo(SourceStream &s)
const;
00576
private:
00577 Node *expr1, *expr2;
00578 Operator oper;
00579 };
00580
00581
class BitOperNode :
public Node {
00582
public:
00583 BitOperNode(Node *e1, Operator o, Node *e2) :
00584 expr1(e1), expr2(e2), oper(o) {}
00585
virtual void ref();
00586
virtual bool deref();
00587
virtual Value evaluate(
ExecState *exec)
const;
00588
virtual void streamTo(SourceStream &s)
const;
00589
private:
00590 Node *expr1, *expr2;
00591 Operator oper;
00592 };
00593
00597 class BinaryLogicalNode :
public Node {
00598
public:
00599
BinaryLogicalNode(Node *e1, Operator o, Node *e2) :
00600 expr1(e1), expr2(e2), oper(o) {}
00601
virtual void ref();
00602
virtual bool deref();
00603
virtual Value evaluate(
ExecState *exec)
const;
00604
virtual void streamTo(SourceStream &s)
const;
00605
private:
00606 Node *expr1, *expr2;
00607 Operator oper;
00608 };
00609
00613 class ConditionalNode :
public Node {
00614
public:
00615
ConditionalNode(Node *l, Node *e1, Node *e2) :
00616 logical(l), expr1(e1), expr2(e2) {}
00617
virtual void ref();
00618
virtual bool deref();
00619
virtual Value evaluate(
ExecState *exec)
const;
00620
virtual void streamTo(SourceStream &s)
const;
00621
private:
00622 Node *logical, *expr1, *expr2;
00623 };
00624
00625
class AssignNode :
public Node {
00626
public:
00627 AssignNode(Node *l, Operator o, Node *e) : left(l), oper(o), expr(e) {}
00628
virtual void ref();
00629
virtual bool deref();
00630
virtual Value evaluate(
ExecState *exec)
const;
00631
virtual void streamTo(SourceStream &s)
const;
00632
private:
00633 Node *left;
00634 Operator oper;
00635 Node *expr;
00636 };
00637
00638
class CommaNode :
public Node {
00639
public:
00640 CommaNode(Node *e1, Node *e2) : expr1(e1), expr2(e2) {}
00641
virtual void ref();
00642
virtual bool deref();
00643
virtual Value evaluate(
ExecState *exec)
const;
00644
virtual void streamTo(SourceStream &s)
const;
00645
private:
00646 Node *expr1, *expr2;
00647 };
00648
00649
class StatListNode :
public StatementNode {
00650
public:
00651
00652 StatListNode(StatementNode *s);
00653 StatListNode(StatListNode *l, StatementNode *s);
00654
virtual void ref();
00655
virtual bool deref();
00656
virtual Completion execute(
ExecState *exec);
00657
virtual void processVarDecls(
ExecState *exec);
00658
virtual void streamTo(SourceStream &s)
const;
00659
private:
00660
friend class CaseClauseNode;
00661 StatementNode *statement;
00662 StatListNode *list;
00663 };
00664
00665
class AssignExprNode :
public Node {
00666
public:
00667 AssignExprNode(Node *e) : expr(e) {}
00668
virtual void ref();
00669
virtual bool deref();
00670
virtual Value evaluate(
ExecState *exec)
const;
00671
virtual void streamTo(SourceStream &s)
const;
00672
private:
00673 Node *expr;
00674 };
00675
00676
class VarDeclNode :
public Node {
00677
public:
00678 VarDeclNode(
const Identifier &
id, AssignExprNode *in);
00679
virtual void ref();
00680
virtual bool deref();
00681
virtual Value evaluate(
ExecState *exec)
const;
00682
virtual void processVarDecls(
ExecState *exec);
00683
virtual void streamTo(SourceStream &s)
const;
00684
private:
00685 Identifier ident;
00686 AssignExprNode *init;
00687 };
00688
00689
class VarDeclListNode :
public Node {
00690
public:
00691
00692 VarDeclListNode(VarDeclNode *v) : list(this), var(v) {}
00693 VarDeclListNode(VarDeclListNode *l, VarDeclNode *v)
00694 : list(l->list), var(v) { l->list =
this; }
00695
virtual void ref();
00696
virtual bool deref();
00697
virtual Value evaluate(
ExecState *exec)
const;
00698
virtual void processVarDecls(
ExecState *exec);
00699
virtual void streamTo(SourceStream &s)
const;
00700
private:
00701
friend class ForNode;
00702
friend class VarStatementNode;
00703 VarDeclListNode *list;
00704 VarDeclNode *var;
00705 };
00706
00707
class VarStatementNode :
public StatementNode {
00708
public:
00709 VarStatementNode(VarDeclListNode *l) : list(l->list) { l->list = 0; }
00710
virtual void ref();
00711
virtual bool deref();
00712
virtual Completion execute(
ExecState *exec);
00713
virtual void processVarDecls(
ExecState *exec);
00714
virtual void streamTo(SourceStream &s)
const;
00715
private:
00716 VarDeclListNode *list;
00717 };
00718
00719
class BlockNode :
public StatementNode {
00720
public:
00721 BlockNode(SourceElementsNode *s);
00722
virtual void ref();
00723
virtual bool deref();
00724
virtual Completion execute(
ExecState *exec);
00725
virtual void processVarDecls(
ExecState *exec);
00726
virtual void streamTo(SourceStream &s)
const;
00727
protected:
00728 SourceElementsNode *source;
00729 };
00730
00731
class EmptyStatementNode :
public StatementNode {
00732
public:
00733 EmptyStatementNode() { }
00734
virtual Completion execute(
ExecState *exec);
00735
virtual void streamTo(SourceStream &s)
const;
00736 };
00737
00738
class ExprStatementNode :
public StatementNode {
00739
public:
00740 ExprStatementNode(Node *e) : expr(e) { }
00741
virtual void ref();
00742
virtual bool deref();
00743
virtual Completion execute(
ExecState *exec);
00744
virtual void streamTo(SourceStream &s)
const;
00745
private:
00746 Node *expr;
00747 };
00748
00749
class IfNode :
public StatementNode {
00750
public:
00751 IfNode(Node *e, StatementNode *s1, StatementNode *s2)
00752 : expr(e), statement1(s1), statement2(s2) {}
00753
virtual void ref();
00754
virtual bool deref();
00755
virtual Completion execute(
ExecState *exec);
00756
virtual void processVarDecls(
ExecState *exec);
00757
virtual void streamTo(SourceStream &s)
const;
00758
private:
00759 Node *expr;
00760 StatementNode *statement1, *statement2;
00761 };
00762
00763
class DoWhileNode :
public StatementNode {
00764
public:
00765 DoWhileNode(StatementNode *s, Node *e) : statement(s), expr(e) {}
00766
virtual void ref();
00767
virtual bool deref();
00768
virtual Completion execute(
ExecState *exec);
00769
virtual void processVarDecls(
ExecState *exec);
00770
virtual void streamTo(SourceStream &s)
const;
00771
private:
00772 StatementNode *statement;
00773 Node *expr;
00774 };
00775
00776
class WhileNode :
public StatementNode {
00777
public:
00778 WhileNode(Node *e, StatementNode *s) : expr(e), statement(s) {}
00779
virtual void ref();
00780
virtual bool deref();
00781
virtual Completion execute(
ExecState *exec);
00782
virtual void processVarDecls(
ExecState *exec);
00783
virtual void streamTo(SourceStream &s)
const;
00784
private:
00785 Node *expr;
00786 StatementNode *statement;
00787 };
00788
00789
class ForNode :
public StatementNode {
00790
public:
00791 ForNode(Node *e1, Node *e2, Node *e3, StatementNode *s) :
00792 expr1(e1), expr2(e2), expr3(e3), statement(s) {}
00793 ForNode(VarDeclListNode *e1, Node *e2, Node *e3, StatementNode *s) :
00794 expr1(e1->list), expr2(e2), expr3(e3), statement(s) { e1->list = 0; }
00795
virtual void ref();
00796
virtual bool deref();
00797
virtual Completion execute(
ExecState *exec);
00798
virtual void processVarDecls(
ExecState *exec);
00799
virtual void streamTo(SourceStream &s)
const;
00800
private:
00801 Node *expr1, *expr2, *expr3;
00802 StatementNode *statement;
00803 };
00804
00805
class ForInNode :
public StatementNode {
00806
public:
00807 ForInNode(Node *l, Node *e, StatementNode *s);
00808 ForInNode(
const Identifier &i, AssignExprNode *in, Node *e, StatementNode *s);
00809
virtual void ref();
00810
virtual bool deref();
00811
virtual Completion execute(
ExecState *exec);
00812
virtual void processVarDecls(
ExecState *exec);
00813
virtual void streamTo(SourceStream &s)
const;
00814
private:
00815 Identifier ident;
00816 AssignExprNode *init;
00817 Node *lexpr, *expr;
00818 VarDeclNode *varDecl;
00819 StatementNode *statement;
00820 };
00821
00822
class ContinueNode :
public StatementNode {
00823
public:
00824 ContinueNode() { }
00825 ContinueNode(
const Identifier &i) : ident(i) { }
00826
virtual Completion execute(
ExecState *exec);
00827
virtual void streamTo(SourceStream &s)
const;
00828
private:
00829 Identifier ident;
00830 };
00831
00832
class BreakNode :
public StatementNode {
00833
public:
00834 BreakNode() { }
00835 BreakNode(
const Identifier &i) : ident(i) { }
00836
virtual Completion execute(
ExecState *exec);
00837
virtual void streamTo(SourceStream &s)
const;
00838
private:
00839 Identifier ident;
00840 };
00841
00842
class ReturnNode :
public StatementNode {
00843
public:
00844 ReturnNode(Node *v) : value(v) {}
00845
virtual void ref();
00846
virtual bool deref();
00847
virtual Completion execute(
ExecState *exec);
00848
virtual void streamTo(SourceStream &s)
const;
00849
private:
00850 Node *value;
00851 };
00852
00853
class WithNode :
public StatementNode {
00854
public:
00855 WithNode(Node *e, StatementNode *s) : expr(e), statement(s) {}
00856
virtual void ref();
00857
virtual bool deref();
00858
virtual Completion execute(
ExecState *exec);
00859
virtual void processVarDecls(
ExecState *exec);
00860
virtual void streamTo(SourceStream &s)
const;
00861
private:
00862 Node *expr;
00863 StatementNode *statement;
00864 };
00865
00866
class CaseClauseNode:
public Node {
00867
public:
00868 CaseClauseNode(Node *e) : expr(e), list(0) { }
00869 CaseClauseNode(Node *e, StatListNode *l)
00870 : expr(e), list(l->list) { l->list = 0; }
00871
virtual void ref();
00872
virtual bool deref();
00873
virtual Value evaluate(
ExecState *exec)
const;
00874
Completion evalStatements(
ExecState *exec)
const;
00875
virtual void processVarDecls(
ExecState *exec);
00876
virtual void streamTo(SourceStream &s)
const;
00877
private:
00878 Node *expr;
00879 StatListNode *list;
00880 };
00881
00882
class ClauseListNode :
public Node {
00883
public:
00884
00885 ClauseListNode(CaseClauseNode *c) : cl(c), nx(this) { }
00886 ClauseListNode(ClauseListNode *n, CaseClauseNode *c)
00887 : cl(c), nx(n->nx) { n->nx =
this; }
00888
virtual void ref();
00889
virtual bool deref();
00890
virtual Value evaluate(
ExecState *exec)
const;
00891 CaseClauseNode *clause()
const {
return cl; }
00892 ClauseListNode *
next()
const {
return nx; }
00893
virtual void processVarDecls(
ExecState *exec);
00894
virtual void streamTo(SourceStream &s)
const;
00895
private:
00896
friend class CaseBlockNode;
00897 CaseClauseNode *cl;
00898 ClauseListNode *nx;
00899 };
00900
00901
class CaseBlockNode:
public Node {
00902
public:
00903 CaseBlockNode(ClauseListNode *l1, CaseClauseNode *d, ClauseListNode *l2);
00904
virtual void ref();
00905
virtual bool deref();
00906
virtual Value evaluate(
ExecState *exec)
const;
00907
Completion evalBlock(
ExecState *exec,
const Value& input)
const;
00908
virtual void processVarDecls(
ExecState *exec);
00909
virtual void streamTo(SourceStream &s)
const;
00910
private:
00911 ClauseListNode *list1;
00912 CaseClauseNode *def;
00913 ClauseListNode *list2;
00914 };
00915
00916
class SwitchNode :
public StatementNode {
00917
public:
00918 SwitchNode(Node *e, CaseBlockNode *b) : expr(e), block(b) { }
00919
virtual void ref();
00920
virtual bool deref();
00921
virtual Completion execute(
ExecState *exec);
00922
virtual void processVarDecls(
ExecState *exec);
00923
virtual void streamTo(SourceStream &s)
const;
00924
private:
00925 Node *expr;
00926 CaseBlockNode *block;
00927 };
00928
00929
class LabelNode :
public StatementNode {
00930
public:
00931 LabelNode(
const Identifier &l, StatementNode *s) :
label(l), statement(s) { }
00932
virtual void ref();
00933
virtual bool deref();
00934
virtual Completion execute(
ExecState *exec);
00935
virtual void processVarDecls(
ExecState *exec);
00936
virtual void streamTo(SourceStream &s)
const;
00937
private:
00938 Identifier
label;
00939 StatementNode *statement;
00940 };
00941
00942
class ThrowNode :
public StatementNode {
00943
public:
00944 ThrowNode(Node *e) : expr(e) {}
00945
virtual void ref();
00946
virtual bool deref();
00947
virtual Completion execute(
ExecState *exec);
00948
virtual void streamTo(SourceStream &s)
const;
00949
private:
00950 Node *expr;
00951 };
00952
00953
class CatchNode :
public StatementNode {
00954
public:
00955 CatchNode(
const Identifier &i, StatementNode *b) : ident(i), block(b) {}
00956
virtual void ref();
00957
virtual bool deref();
00958
virtual Completion execute(
ExecState *exec);
00959
Completion execute(
ExecState *exec,
const Value &arg);
00960
virtual void processVarDecls(
ExecState *exec);
00961
virtual void streamTo(SourceStream &s)
const;
00962
private:
00963 Identifier ident;
00964 StatementNode *block;
00965 };
00966
00967
class FinallyNode :
public StatementNode {
00968
public:
00969 FinallyNode(StatementNode *b) : block(b) {}
00970
virtual void ref();
00971
virtual bool deref();
00972
virtual Completion execute(
ExecState *exec);
00973
virtual void processVarDecls(
ExecState *exec);
00974
virtual void streamTo(SourceStream &s)
const;
00975
private:
00976 StatementNode *block;
00977 };
00978
00979
class TryNode :
public StatementNode {
00980
public:
00981 TryNode(StatementNode *b, CatchNode *c)
00982 : block(b), _catch(c), _final(0) {}
00983 TryNode(StatementNode *b, FinallyNode *f)
00984 : block(b), _catch(0), _final(f) {}
00985 TryNode(StatementNode *b, CatchNode *c, FinallyNode *f)
00986 : block(b), _catch(c), _final(f) {}
00987
virtual void ref();
00988
virtual bool deref();
00989
virtual Completion execute(
ExecState *exec);
00990
virtual void processVarDecls(
ExecState *exec);
00991
virtual void streamTo(SourceStream &s)
const;
00992
private:
00993 StatementNode *block;
00994 CatchNode *_catch;
00995 FinallyNode *_final;
00996 };
00997
00998
class ParameterNode :
public Node {
00999
public:
01000
01001 ParameterNode(
const Identifier &i) : id(i),
next(this) { }
01002 ParameterNode(ParameterNode *list,
const Identifier &i)
01003 : id(i),
next(list->
next) { list->next =
this; }
01004
virtual void ref();
01005
virtual bool deref();
01006
virtual Value evaluate(
ExecState *exec)
const;
01007 Identifier ident()
const {
return id; }
01008 ParameterNode *nextParam()
const {
return next; }
01009
virtual void streamTo(SourceStream &s)
const;
01010
private:
01011
friend class FuncDeclNode;
01012
friend class FuncExprNode;
01013 Identifier
id;
01014 ParameterNode *
next;
01015 };
01016
01017
class FunctionBodyNode :
public BlockNode {
01018
public:
01019 FunctionBodyNode(SourceElementsNode *s);
01020
virtual void processFuncDecl(
ExecState *exec);
01021
virtual Completion execute(
ExecState *exec);
01022
void setProgram(
bool _program) { program = _program; }
01023
bool isProgram()
const {
return program; }
01024
private:
01025
bool program;
01026 };
01027
01028
class FuncDeclNode :
public StatementNode {
01029
public:
01030 FuncDeclNode(
const Identifier &i, FunctionBodyNode *b)
01031 : ident(i), param(0), body(b) { }
01032 FuncDeclNode(
const Identifier &i, ParameterNode *p, FunctionBodyNode *b)
01033 : ident(i), param(p->
next), body(b) { p->next = 0; }
01034
virtual void ref();
01035
virtual bool deref();
01036
Completion execute(
ExecState* )
01037 {
return Completion(); }
01038
void processFuncDecl(
ExecState *exec);
01039
virtual void streamTo(SourceStream &s)
const;
01040
private:
01041 Identifier ident;
01042 ParameterNode *param;
01043 FunctionBodyNode *body;
01044 };
01045
01046
class FuncExprNode :
public Node {
01047
public:
01048 FuncExprNode(FunctionBodyNode *b)
01049 : param(0), body(b) { }
01050 FuncExprNode(ParameterNode *p, FunctionBodyNode *b)
01051 : param(p->
next), body(b) { p->next = 0; }
01052
virtual void ref();
01053
virtual bool deref();
01054
virtual Value evaluate(
ExecState *exec)
const;
01055
virtual void streamTo(SourceStream &s)
const;
01056
private:
01057 ParameterNode *param;
01058 FunctionBodyNode *body;
01059 };
01060
01061
01062
class SourceElementsNode :
public StatementNode {
01063
public:
01064
01065 SourceElementsNode(StatementNode *s1);
01066 SourceElementsNode(SourceElementsNode *s1, StatementNode *s2);
01067
virtual void ref();
01068
virtual bool deref();
01069
Completion execute(
ExecState *exec);
01070
virtual void processFuncDecl(
ExecState *exec);
01071
virtual void processVarDecls(
ExecState *exec);
01072
virtual void streamTo(SourceStream &s)
const;
01073
private:
01074
friend class BlockNode;
01075 StatementNode *element;
01076 SourceElementsNode *elements;
01077 };
01078
01079 }
01080
01081
#endif