38 class SourceElementsNode;
39 class ObjectLiteralNode;
42 class PropertyValueNode;
45 enum Operator { OpEqual,
82 virtual Type type()
const {
return UnspecifiedType; }
87 virtual Reference evaluateReference(ExecState *exec)
const;
91 virtual Value evaluate(ExecState *exec)
const;
92 virtual bool toBoolean(ExecState *exec)
const;
93 virtual double toNumber(ExecState *exec)
const;
94 virtual UString toString(ExecState *exec)
const;
96 UString toCode()
const;
97 virtual void streamTo(SourceStream &s)
const = 0;
98 virtual void processVarDecls(ExecState* ) {}
99 int lineNo()
const {
return line; }
103 virtual void ref() { refcount++; }
105 virtual bool deref() { assert( refcount > 0 );
return (!--refcount); }
107 virtual bool deref() {
return (!--refcount); }
112 static void finalCheck();
115 Value throwError(ExecState *exec, ErrorType e,
const char *msg)
const;
116 Value throwError(ExecState *exec, ErrorType e,
const char *msg,
117 const Value &v,
const Node *expr)
const;
118 Value throwError(ExecState *exec, ErrorType e,
const char *msg, Identifier label)
const;
119 void setExceptionDetailsIfNeeded(ExecState *exec)
const;
121 unsigned int refcount;
122 virtual int sourceId()
const {
return -1; }
126 static std::list<Node *> *s_nodes;
129 Node& operator=(
const Node&);
130 Node(
const Node &other);
133 class StatementNode :
public Node {
136 virtual ~StatementNode();
137 void setLoc(
int line0,
int line1, SourceCode *src);
138 int firstLine()
const {
return l0; }
139 int lastLine()
const {
return l1; }
140 int sourceId()
const {
return sourceCode->sid; }
141 SourceCode *code()
const {
return sourceCode; }
142 bool hitStatement(ExecState *exec);
143 bool abortStatement(ExecState *exec);
144 virtual Completion execute(ExecState *exec) = 0;
145 void pushLabel(
const Identifier &
id) { ls.push(
id); }
146 virtual void processFuncDecl(ExecState *exec);
150 Reference evaluateReference(ExecState* )
const {
return Reference(0,
Identifier::null()); }
152 SourceCode *sourceCode;
156 class NullNode :
public Node {
159 virtual Value evaluate(ExecState *exec)
const;
160 virtual bool toBoolean(ExecState *exec)
const;
161 virtual double toNumber(ExecState *exec)
const;
162 virtual UString toString(ExecState *exec)
const;
163 virtual void streamTo(SourceStream &s)
const;
166 class BooleanNode :
public Node {
168 BooleanNode(
bool v) : val(v) {}
169 virtual Type type()
const {
return BooleanType; }
170 virtual Value evaluate(ExecState *exec)
const;
171 virtual bool toBoolean(ExecState *exec)
const;
172 virtual double toNumber(ExecState *exec)
const;
173 virtual UString toString(ExecState *exec)
const;
174 virtual void streamTo(SourceStream &s)
const;
179 class NumberNode :
public Node {
181 NumberNode(
double v) : val(v) { }
182 virtual Type type()
const {
return NumberType; }
183 virtual Value evaluate(ExecState *exec)
const;
184 virtual bool toBoolean(ExecState *exec)
const;
185 virtual double toNumber(ExecState *exec)
const;
186 virtual UString toString(ExecState *exec)
const;
187 virtual void streamTo(SourceStream &s)
const;
192 class StringNode :
public Node {
194 StringNode(
const UString *v) : val(*v) { }
195 virtual Type type()
const {
return StringType; }
196 virtual Value evaluate(ExecState *exec)
const;
197 virtual bool toBoolean(ExecState *exec)
const;
198 virtual double toNumber(ExecState *exec)
const;
199 virtual UString toString(ExecState *exec)
const;
200 virtual void streamTo(SourceStream &s)
const;
205 class RegExpNode :
public Node {
207 RegExpNode(
const UString &p,
const UString &f)
208 : pattern(p), flags(f) { }
209 virtual Value evaluate(ExecState *exec)
const;
210 virtual bool toBoolean(ExecState *exec)
const;
211 virtual void streamTo(SourceStream &s)
const;
213 UString pattern, flags;
216 class ThisNode :
public Node {
219 virtual Value evaluate(ExecState *exec)
const;
220 virtual void streamTo(SourceStream &s)
const;
223 class ResolveNode :
public Node {
225 ResolveNode(
const Identifier &s) : ident(s) { }
226 Reference evaluateReference(ExecState *exec)
const;
227 virtual Value evaluate(ExecState *exec)
const;
228 virtual void streamTo(SourceStream &s)
const;
233 class GroupNode :
public Node {
235 GroupNode(Node *g) : group(g) { }
237 virtual bool deref();
238 Reference evaluateReference(ExecState *exec)
const;
239 virtual Value evaluate(ExecState *exec)
const;
240 virtual void streamTo(SourceStream &s)
const;
245 class ElementNode :
public Node {
248 ElementNode(
int e, Node *n) : list(this), elision(e), node(n) { }
249 ElementNode(ElementNode *l,
int e, Node *n)
250 : list(l->list), elision(e), node(n) { l->list =
this; }
252 virtual bool deref();
253 virtual Value evaluate(ExecState *exec)
const;
254 virtual void streamTo(SourceStream &s)
const;
256 friend class ArrayNode;
262 class ArrayNode :
public Node {
264 ArrayNode(
int e) : element(0L), elision(e), opt(true) { }
265 ArrayNode(ElementNode *ele)
266 : element(ele->list), elision(0), opt(false) { ele->list = 0; }
267 ArrayNode(
int eli, ElementNode *ele)
268 : element(ele->list), elision(eli), opt(true) { ele->list = 0; }
270 virtual bool deref();
271 virtual Value evaluate(ExecState *exec)
const;
272 virtual void streamTo(SourceStream &s)
const;
274 ElementNode *element;
279 class PropertyValueNode :
public Node {
282 PropertyValueNode(PropertyNode *n, Node *a)
283 :
name(n), assign(a), list(this) { }
284 PropertyValueNode(PropertyNode *n, Node *a, PropertyValueNode *l)
285 :
name(n), assign(a), list(l->list) { l->list =
this; }
287 virtual bool deref();
288 virtual Value evaluate(ExecState *exec)
const;
289 virtual void streamTo(SourceStream &s)
const;
291 friend class ObjectLiteralNode;
294 PropertyValueNode *list;
297 class PropertyNode :
public Node {
299 PropertyNode(
double d) : numeric(d) { }
300 PropertyNode(
const Identifier &s) : str(s) { }
301 virtual Value evaluate(ExecState *exec)
const;
302 virtual void streamTo(SourceStream &s)
const;
308 class ObjectLiteralNode :
public Node {
311 ObjectLiteralNode() : list(0) { }
313 ObjectLiteralNode(PropertyValueNode *l) : list(l->list) { l->list = 0; }
315 virtual bool deref();
316 virtual Value evaluate(ExecState *exec)
const;
317 virtual void streamTo(SourceStream &s)
const;
319 PropertyValueNode *list;
322 class AccessorNode1 :
public Node {
324 AccessorNode1(Node *e1, Node *e2) : expr1(e1), expr2(e2) {}
326 virtual bool deref();
327 Reference evaluateReference(ExecState *exec)
const;
328 virtual void streamTo(SourceStream &s)
const;
334 class AccessorNode2 :
public Node {
336 AccessorNode2(Node *e,
const Identifier &s) : expr(e), ident(s) { }
338 virtual bool deref();
339 Reference evaluateReference(ExecState *exec)
const;
340 virtual void streamTo(SourceStream &s)
const;
346 class ArgumentListNode :
public Node {
349 ArgumentListNode(Node *e) : list(this), expr(e) {}
350 ArgumentListNode(ArgumentListNode *l, Node *e)
351 : list(l->list), expr(e) { l->list =
this; }
353 virtual bool deref();
354 virtual Value evaluate(ExecState *exec)
const;
355 List evaluateList(ExecState *exec)
const;
356 virtual void streamTo(SourceStream &s)
const;
358 friend class ArgumentsNode;
359 ArgumentListNode *list;
363 class ArgumentsNode :
public Node {
365 ArgumentsNode() : list(0) {}
366 ArgumentsNode(ArgumentListNode *l) : list(l->list) { l->list = 0; }
368 virtual bool deref();
369 virtual Value evaluate(ExecState *exec)
const;
370 List evaluateList(ExecState *exec)
const;
371 virtual void streamTo(SourceStream &s)
const;
373 ArgumentListNode *list;
376 class NewExprNode :
public Node {
378 NewExprNode(Node *e) : expr(e), args(0L) {}
379 NewExprNode(Node *e, ArgumentsNode *a) : expr(e), args(a) {}
381 virtual bool deref();
382 virtual Value evaluate(ExecState *exec)
const;
383 virtual void streamTo(SourceStream &s)
const;
389 class FunctionCallNode :
public Node {
391 FunctionCallNode(Node *e, ArgumentsNode *a) : expr(e), args(a) {}
393 virtual bool deref();
394 virtual Value evaluate(ExecState *exec)
const;
395 virtual void streamTo(SourceStream &s)
const;
401 class PostfixNode :
public Node {
403 PostfixNode(Node *e, Operator o) : expr(e), oper(o) {}
405 virtual bool deref();
406 virtual Value evaluate(ExecState *exec)
const;
407 virtual void streamTo(SourceStream &s)
const;
413 class DeleteNode :
public Node {
415 DeleteNode(Node *e) : expr(e) {}
417 virtual bool deref();
418 virtual Value evaluate(ExecState *exec)
const;
419 virtual void streamTo(SourceStream &s)
const;
424 class VoidNode :
public Node {
426 VoidNode(Node *e) : expr(e) {}
428 virtual bool deref();
429 virtual Value evaluate(ExecState *exec)
const;
430 virtual void streamTo(SourceStream &s)
const;
435 class TypeOfNode :
public Node {
437 TypeOfNode(Node *e) : expr(e) {}
439 virtual bool deref();
440 virtual Value evaluate(ExecState *exec)
const;
441 virtual void streamTo(SourceStream &s)
const;
446 class PrefixNode :
public Node {
448 PrefixNode(Operator o, Node *e) : oper(o), expr(e) {}
450 virtual bool deref();
451 virtual Value evaluate(ExecState *exec)
const;
452 virtual void streamTo(SourceStream &s)
const;
458 class UnaryPlusNode :
public Node {
460 UnaryPlusNode(Node *e) : expr(e) {}
462 virtual bool deref();
463 virtual Value evaluate(ExecState *exec)
const;
464 virtual double toNumber(ExecState *exec)
const;
465 virtual void streamTo(SourceStream &s)
const;
470 class NegateNode :
public Node {
472 NegateNode(Node *e) : expr(e) {}
474 virtual bool deref();
475 virtual Value evaluate(ExecState *exec)
const;
476 virtual double toNumber(ExecState *exec)
const;
477 virtual void streamTo(SourceStream &s)
const;
482 class BitwiseNotNode :
public Node {
484 BitwiseNotNode(Node *e) : expr(e) {}
486 virtual bool deref();
487 virtual Value evaluate(ExecState *exec)
const;
488 virtual void streamTo(SourceStream &s)
const;
493 class LogicalNotNode :
public Node {
495 LogicalNotNode(Node *e) : expr(e) {}
497 virtual bool deref();
498 virtual Value evaluate(ExecState *exec)
const;
499 virtual bool toBoolean(ExecState *exec)
const;
500 virtual void streamTo(SourceStream &s)
const;
505 class MultNode :
public Node {
507 MultNode(Node *t1, Node *t2,
char op) : term1(t1), term2(t2), oper(op) {}
509 virtual bool deref();
510 virtual Value evaluate(ExecState *exec)
const;
511 virtual void streamTo(SourceStream &s)
const;
517 class AddNode :
public Node {
519 AddNode(Node *t1, Node *t2,
char op) : term1(t1), term2(t2), oper(op) {}
521 static Node* create(Node *t1, Node *t2,
char op);
524 virtual bool deref();
525 virtual Value evaluate(ExecState *exec)
const;
526 virtual void streamTo(SourceStream &s)
const;
532 class AppendStringNode :
public Node {
534 AppendStringNode(Node *t,
const UString &s) : term(t), str(s) { }
536 virtual bool deref();
537 virtual Value evaluate(ExecState *exec)
const;
538 virtual void streamTo(SourceStream &s)
const;
544 class ShiftNode :
public Node {
546 ShiftNode(Node *t1, Operator o, Node *t2)
547 : term1(t1), term2(t2), oper(o) {}
549 virtual bool deref();
550 virtual Value evaluate(ExecState *exec)
const;
551 virtual void streamTo(SourceStream &s)
const;
557 class RelationalNode :
public Node {
559 RelationalNode(Node *e1, Operator o, Node *e2) :
560 expr1(e1), expr2(e2), oper(o) {}
562 virtual bool deref();
563 virtual Value evaluate(ExecState *exec)
const;
564 virtual void streamTo(SourceStream &s)
const;
570 class EqualNode :
public Node {
572 EqualNode(Node *e1, Operator o, Node *e2)
573 : expr1(e1), expr2(e2), oper(o) {}
575 virtual bool deref();
576 virtual Value evaluate(ExecState *exec)
const;
577 virtual void streamTo(SourceStream &s)
const;
583 class BitOperNode :
public Node {
585 BitOperNode(Node *e1, Operator o, Node *e2) :
586 expr1(e1), expr2(e2), oper(o) {}
588 virtual bool deref();
589 virtual Value evaluate(ExecState *exec)
const;
590 virtual void streamTo(SourceStream &s)
const;
602 expr1(e1), expr2(e2), oper(o) {}
604 virtual bool deref();
606 virtual void streamTo(SourceStream &s)
const;
618 logical(l), expr1(e1), expr2(e2) {}
620 virtual bool deref();
622 virtual void streamTo(SourceStream &s)
const;
624 Node *logical, *expr1, *expr2;
627 class AssignNode :
public Node {
629 AssignNode(Node *l, Operator o, Node *e) : left(l), oper(o), expr(e) {}
631 virtual bool deref();
632 virtual Value evaluate(ExecState *exec)
const;
633 virtual void streamTo(SourceStream &s)
const;
640 class CommaNode :
public Node {
642 CommaNode(Node *e1, Node *e2) : expr1(e1), expr2(e2) {}
644 virtual bool deref();
645 virtual Value evaluate(ExecState *exec)
const;
646 virtual void streamTo(SourceStream &s)
const;
651 class StatListNode :
public StatementNode {
654 StatListNode(StatementNode *s);
655 StatListNode(StatListNode *l, StatementNode *s);
657 virtual bool deref();
658 virtual Completion execute(ExecState *exec);
659 virtual void processVarDecls(ExecState *exec);
660 virtual void streamTo(SourceStream &s)
const;
662 friend class CaseClauseNode;
663 StatementNode *statement;
667 class AssignExprNode :
public Node {
669 AssignExprNode(Node *e) : expr(e) {}
671 virtual bool deref();
672 virtual Value evaluate(ExecState *exec)
const;
673 virtual void streamTo(SourceStream &s)
const;
678 class VarDeclNode :
public Node {
680 enum Type { Variable, Constant };
681 VarDeclNode(
const Identifier &
id, AssignExprNode *in, Type t);
683 virtual bool deref();
684 virtual Value evaluate(ExecState *exec)
const;
685 virtual void processVarDecls(ExecState *exec);
686 virtual void streamTo(SourceStream &s)
const;
690 AssignExprNode *init;
693 class VarDeclListNode :
public Node {
696 VarDeclListNode(VarDeclNode *v) : list(this), var(v) {}
697 VarDeclListNode(VarDeclListNode *l, VarDeclNode *v)
698 : list(l->list), var(v) { l->list =
this; }
700 virtual bool deref();
701 virtual Value evaluate(ExecState *exec)
const;
702 virtual void processVarDecls(ExecState *exec);
703 virtual void streamTo(SourceStream &s)
const;
705 friend class ForNode;
706 friend class VarStatementNode;
707 VarDeclListNode *list;
711 class VarStatementNode :
public StatementNode {
713 VarStatementNode(VarDeclListNode *l) : list(l->list) { l->list = 0; }
715 virtual bool deref();
716 virtual Completion execute(ExecState *exec);
717 virtual void processVarDecls(ExecState *exec);
718 virtual void streamTo(SourceStream &s)
const;
720 VarDeclListNode *list;
723 class BlockNode :
public StatementNode {
725 BlockNode(SourceElementsNode *s);
727 virtual bool deref();
728 virtual Completion execute(ExecState *exec);
729 virtual void processVarDecls(ExecState *exec);
730 virtual void streamTo(SourceStream &s)
const;
732 SourceElementsNode *source;
735 class EmptyStatementNode :
public StatementNode {
737 EmptyStatementNode() { }
738 virtual Completion execute(ExecState *exec);
739 virtual void streamTo(SourceStream &s)
const;
742 class ExprStatementNode :
public StatementNode {
744 ExprStatementNode(Node *e) : expr(e) { }
746 virtual bool deref();
747 virtual Completion execute(ExecState *exec);
748 virtual void streamTo(SourceStream &s)
const;
753 class IfNode :
public StatementNode {
755 IfNode(Node *e, StatementNode *s1, StatementNode *s2)
756 : expr(e), statement1(s1), statement2(s2) {}
758 virtual bool deref();
759 virtual Completion execute(ExecState *exec);
760 virtual void processVarDecls(ExecState *exec);
761 virtual void streamTo(SourceStream &s)
const;
764 StatementNode *statement1, *statement2;
767 class DoWhileNode :
public StatementNode {
769 DoWhileNode(StatementNode *s, Node *e) : statement(s), expr(e) {}
771 virtual bool deref();
772 virtual Completion execute(ExecState *exec);
773 virtual void processVarDecls(ExecState *exec);
774 virtual void streamTo(SourceStream &s)
const;
776 StatementNode *statement;
780 class WhileNode :
public StatementNode {
782 WhileNode(Node *e, StatementNode *s) : expr(e), statement(s) {}
784 virtual bool deref();
785 virtual Completion execute(ExecState *exec);
786 virtual void processVarDecls(ExecState *exec);
787 virtual void streamTo(SourceStream &s)
const;
790 StatementNode *statement;
793 class ForNode :
public StatementNode {
795 ForNode(Node *e1, Node *e2, Node *e3, StatementNode *s) :
796 expr1(e1), expr2(e2), expr3(e3), statement(s) {}
797 ForNode(VarDeclListNode *e1, Node *e2, Node *e3, StatementNode *s) :
798 expr1(e1->list), expr2(e2), expr3(e3), statement(s) { e1->list = 0; }
800 virtual bool deref();
801 virtual Completion execute(ExecState *exec);
802 virtual void processVarDecls(ExecState *exec);
803 virtual void streamTo(SourceStream &s)
const;
805 Node *expr1, *expr2, *expr3;
806 StatementNode *statement;
809 class ForInNode :
public StatementNode {
811 ForInNode(Node *l, Node *e, StatementNode *s);
812 ForInNode(
const Identifier &i, AssignExprNode *in, Node *e, StatementNode *s);
814 virtual bool deref();
815 virtual Completion execute(ExecState *exec);
816 virtual void processVarDecls(ExecState *exec);
817 virtual void streamTo(SourceStream &s)
const;
820 AssignExprNode *init;
822 VarDeclNode *varDecl;
823 StatementNode *statement;
826 class ContinueNode :
public StatementNode {
829 ContinueNode(
const Identifier &i) : ident(i) { }
830 virtual Completion execute(ExecState *exec);
831 virtual void streamTo(SourceStream &s)
const;
836 class BreakNode :
public StatementNode {
839 BreakNode(
const Identifier &i) : ident(i) { }
840 virtual Completion execute(ExecState *exec);
841 virtual void streamTo(SourceStream &s)
const;
846 class ReturnNode :
public StatementNode {
848 ReturnNode(Node *v) : value(v) {}
850 virtual bool deref();
851 virtual Completion execute(ExecState *exec);
852 virtual void streamTo(SourceStream &s)
const;
857 class WithNode :
public StatementNode {
859 WithNode(Node *e, StatementNode *s) : expr(e), statement(s) {}
861 virtual bool deref();
862 virtual Completion execute(ExecState *exec);
863 virtual void processVarDecls(ExecState *exec);
864 virtual void streamTo(SourceStream &s)
const;
867 StatementNode *statement;
870 class CaseClauseNode :
public Node {
872 CaseClauseNode(Node *e) : expr(e), list(0) { }
873 CaseClauseNode(Node *e, StatListNode *l)
874 : expr(e), list(l->list) { l->list = 0; }
876 virtual bool deref();
877 virtual Value evaluate(ExecState *exec)
const;
878 Completion evalStatements(ExecState *exec)
const;
879 virtual void processVarDecls(ExecState *exec);
880 virtual void streamTo(SourceStream &s)
const;
886 class ClauseListNode :
public Node {
889 ClauseListNode(CaseClauseNode *c) : cl(c), nx(this) { }
890 ClauseListNode(ClauseListNode *n, CaseClauseNode *c)
891 : cl(c), nx(n->nx) { n->nx =
this; }
893 virtual bool deref();
894 virtual Value evaluate(ExecState *exec)
const;
895 CaseClauseNode *clause()
const {
return cl; }
896 ClauseListNode *
next()
const {
return nx; }
897 virtual void processVarDecls(ExecState *exec);
898 virtual void streamTo(SourceStream &s)
const;
900 friend class CaseBlockNode;
905 class CaseBlockNode:
public Node {
907 CaseBlockNode(ClauseListNode *l1, CaseClauseNode *d, ClauseListNode *l2);
909 virtual bool deref();
910 virtual Value evaluate(ExecState *exec)
const;
911 Completion evalBlock(ExecState *exec,
const Value& input)
const;
912 virtual void processVarDecls(ExecState *exec);
913 virtual void streamTo(SourceStream &s)
const;
915 ClauseListNode *list1;
917 ClauseListNode *list2;
920 class SwitchNode :
public StatementNode {
922 SwitchNode(Node *e, CaseBlockNode *b) : expr(e), block(b) { }
924 virtual bool deref();
925 virtual Completion execute(ExecState *exec);
926 virtual void processVarDecls(ExecState *exec);
927 virtual void streamTo(SourceStream &s)
const;
930 CaseBlockNode *block;
933 class LabelNode :
public StatementNode {
935 LabelNode(
const Identifier &l, StatementNode *s) :
label(l), statement(s) { }
937 virtual bool deref();
938 virtual Completion execute(ExecState *exec);
939 virtual void processVarDecls(ExecState *exec);
940 virtual void streamTo(SourceStream &s)
const;
943 StatementNode *statement;
946 class ThrowNode :
public StatementNode {
948 ThrowNode(Node *e) : expr(e) {}
950 virtual bool deref();
951 virtual Completion execute(ExecState *exec);
952 virtual void streamTo(SourceStream &s)
const;
957 class CatchNode :
public StatementNode {
959 CatchNode(
const Identifier &i, StatementNode *b) : ident(i), block(b) {}
961 virtual bool deref();
962 virtual Completion execute(ExecState *exec);
963 Completion execute(ExecState *exec,
const Value &arg);
964 virtual void processVarDecls(ExecState *exec);
965 virtual void streamTo(SourceStream &s)
const;
968 StatementNode *block;
971 class FinallyNode :
public StatementNode {
973 FinallyNode(StatementNode *b) : block(b) {}
975 virtual bool deref();
976 virtual Completion execute(ExecState *exec);
977 virtual void processVarDecls(ExecState *exec);
978 virtual void streamTo(SourceStream &s)
const;
980 StatementNode *block;
983 class TryNode :
public StatementNode {
985 TryNode(StatementNode *b, CatchNode *c)
986 : block(b), _catch(c), _final(0) {}
987 TryNode(StatementNode *b, FinallyNode *f)
988 : block(b), _catch(0), _final(f) {}
989 TryNode(StatementNode *b, CatchNode *c, FinallyNode *f)
990 : block(b), _catch(c), _final(f) {}
992 virtual bool deref();
993 virtual Completion execute(ExecState *exec);
994 virtual void processVarDecls(ExecState *exec);
995 virtual void streamTo(SourceStream &s)
const;
997 StatementNode *block;
1002 class ParameterNode :
public Node {
1005 ParameterNode(
const Identifier &i) : id(i),
next(this) { }
1006 ParameterNode(ParameterNode *list,
const Identifier &i)
1007 : id(i),
next(list->
next) { list->next =
this; }
1009 virtual bool deref();
1010 virtual Value evaluate(ExecState *exec)
const;
1011 Identifier ident()
const {
return id; }
1012 ParameterNode *nextParam()
const {
return next; }
1013 virtual void streamTo(SourceStream &s)
const;
1015 friend class FuncDeclNode;
1016 friend class FuncExprNode;
1018 ParameterNode *
next;
1022 class FunctionBodyNode :
public BlockNode {
1024 FunctionBodyNode(SourceElementsNode *s);
1025 virtual void processFuncDecl(ExecState *exec);
1028 class FuncDeclNode :
public StatementNode {
1030 FuncDeclNode(
const Identifier &i, FunctionBodyNode *b)
1031 : ident(i), param(0), body(b) { }
1032 FuncDeclNode(
const Identifier &i, ParameterNode *p, FunctionBodyNode *b)
1033 : ident(i), param(p->
next), body(b) { p->next = 0; }
1035 virtual bool deref();
1036 Completion execute(ExecState* )
1037 {
return Completion(); }
1038 void processFuncDecl(ExecState *exec);
1039 virtual void streamTo(SourceStream &s)
const;
1042 ParameterNode *param;
1043 FunctionBodyNode *body;
1046 class FuncExprNode :
public Node {
1048 FuncExprNode(
const Identifier &i, FunctionBodyNode *b)
1049 : ident(i), param(0), body(b) { }
1050 FuncExprNode(
const Identifier &i, ParameterNode *p, FunctionBodyNode *b)
1051 : ident(i), param(p->
next), body(b) { p->next = 0; }
1053 virtual bool deref();
1054 virtual Value evaluate(ExecState *exec)
const;
1055 virtual void streamTo(SourceStream &s)
const;
1058 ParameterNode *param;
1059 FunctionBodyNode *body;
1063 class SourceElementsNode :
public StatementNode {
1066 SourceElementsNode(StatementNode *s1);
1067 SourceElementsNode(SourceElementsNode *s1, StatementNode *s2);
1069 virtual bool deref();
1070 Completion execute(ExecState *exec);
1071 virtual void processFuncDecl(ExecState *exec);
1072 virtual void processVarDecls(ExecState *exec);
1073 virtual void streamTo(SourceStream &s)
const;
1075 friend class BlockNode;
1076 StatementNode *element;
1077 SourceElementsNode *elements;
expr1 && expr2, expr1 || expr2
The ternary operator, "logical ? expr1 : expr2".
Represents the current state of script execution.
static const Identifier & null()
Creates an empty Identifier.
Value objects are act as wrappers ("smart pointers") around ValueImp objects and their descendents.
TQString name(StdAccel id)
TQString label(StdAccel id)