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