1 /****************************************************************************
2 **
3 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
5 **
6 ** This file is part of the Qt Solutions component.
7 **
8 ** $QT_BEGIN_LICENSE:BSD$
9 ** You may use this file under the terms of the BSD license as follows:
10 **
11 ** "Redistribution and use in source and binary forms, with or without
12 ** modification, are permitted provided that the following conditions are
13 ** met:
14 ** * Redistributions of source code must retain the above copyright
15 ** notice, this list of conditions and the following disclaimer.
16 ** * Redistributions in binary form must reproduce the above copyright
17 ** notice, this list of conditions and the following disclaimer in
18 ** the documentation and/or other materials provided with the
19 ** distribution.
20 ** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
21 ** of its contributors may be used to endorse or promote products derived
22 ** from this software without specific prior written permission.
23 **
24 **
25 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
36 **
37 ** $QT_END_LICENSE$
38 **
39 ****************************************************************************/
40
41
42 #include "qscriptast_p.h"
43
44
45 #include "qscriptastvisitor_p.h"
46
47 QT_BEGIN_NAMESPACE
48
49 namespace QScript { namespace AST {
50
expressionCast()51 ExpressionNode *Node::expressionCast()
52 {
53 return 0;
54 }
55
binaryExpressionCast()56 BinaryExpression *Node::binaryExpressionCast()
57 {
58 return 0;
59 }
60
statementCast()61 Statement *Node::statementCast()
62 {
63 return 0;
64 }
65
expressionCast()66 ExpressionNode *ExpressionNode::expressionCast()
67 {
68 return this;
69 }
70
binaryExpressionCast()71 BinaryExpression *BinaryExpression::binaryExpressionCast()
72 {
73 return this;
74 }
75
statementCast()76 Statement *Statement::statementCast()
77 {
78 return this;
79 }
80
accept0(Visitor * visitor)81 void ThisExpression::accept0(Visitor *visitor)
82 {
83 if (visitor->visit(this)) {
84 }
85
86 visitor->endVisit(this);
87 }
88
accept0(Visitor * visitor)89 void IdentifierExpression::accept0(Visitor *visitor)
90 {
91 if (visitor->visit(this)) {
92 }
93
94 visitor->endVisit(this);
95 }
96
accept0(Visitor * visitor)97 void NullExpression::accept0(Visitor *visitor)
98 {
99 if (visitor->visit(this)) {
100 }
101
102 visitor->endVisit(this);
103 }
104
accept0(Visitor * visitor)105 void TrueLiteral::accept0(Visitor *visitor)
106 {
107 if (visitor->visit(this)) {
108 }
109
110 visitor->endVisit(this);
111 }
112
accept0(Visitor * visitor)113 void FalseLiteral::accept0(Visitor *visitor)
114 {
115 if (visitor->visit(this)) {
116 }
117
118 visitor->endVisit(this);
119 }
120
accept0(Visitor * visitor)121 void StringLiteral::accept0(Visitor *visitor)
122 {
123 if (visitor->visit(this)) {
124 }
125
126 visitor->endVisit(this);
127 }
128
accept0(Visitor * visitor)129 void NumericLiteral::accept0(Visitor *visitor)
130 {
131 if (visitor->visit(this)) {
132 }
133
134 visitor->endVisit(this);
135 }
136
accept0(Visitor * visitor)137 void RegExpLiteral::accept0(Visitor *visitor)
138 {
139 if (visitor->visit(this)) {
140 }
141
142 visitor->endVisit(this);
143 }
144
accept0(Visitor * visitor)145 void ArrayLiteral::accept0(Visitor *visitor)
146 {
147 if (visitor->visit(this)) {
148 acceptChild(elements, visitor);
149 acceptChild(elision, visitor);
150 }
151
152 visitor->endVisit(this);
153 }
154
accept0(Visitor * visitor)155 void ObjectLiteral::accept0(Visitor *visitor)
156 {
157 if (visitor->visit(this)) {
158 acceptChild(properties, visitor);
159 }
160
161 visitor->endVisit(this);
162 }
163
accept0(Visitor * visitor)164 void ElementList::accept0(Visitor *visitor)
165 {
166 if (visitor->visit(this)) {
167 ElementList *it = this;
168 do {
169 acceptChild(it->elision, visitor);
170 acceptChild(it->expression, visitor);
171 it = it->next;
172 } while (it);
173 }
174
175 visitor->endVisit(this);
176 }
177
accept0(Visitor * visitor)178 void Elision::accept0(Visitor *visitor)
179 {
180 if (visitor->visit(this)) {
181 // ###
182 }
183
184 visitor->endVisit(this);
185 }
186
accept0(Visitor * visitor)187 void PropertyNameAndValueList::accept0(Visitor *visitor)
188 {
189 if (visitor->visit(this)) {
190 PropertyNameAndValueList *it = this;
191 do {
192 acceptChild(it->name, visitor);
193 acceptChild(it->value, visitor);
194 it = it->next;
195 } while (it);
196 }
197
198 visitor->endVisit(this);
199 }
200
accept0(Visitor * visitor)201 void IdentifierPropertyName::accept0(Visitor *visitor)
202 {
203 if (visitor->visit(this)) {
204 }
205
206 visitor->endVisit(this);
207 }
208
accept0(Visitor * visitor)209 void StringLiteralPropertyName::accept0(Visitor *visitor)
210 {
211 if (visitor->visit(this)) {
212 }
213
214 visitor->endVisit(this);
215 }
216
accept0(Visitor * visitor)217 void NumericLiteralPropertyName::accept0(Visitor *visitor)
218 {
219 if (visitor->visit(this)) {
220 }
221
222 visitor->endVisit(this);
223 }
224
accept0(Visitor * visitor)225 void ArrayMemberExpression::accept0(Visitor *visitor)
226 {
227 if (visitor->visit(this)) {
228 acceptChild(base, visitor);
229 acceptChild(expression, visitor);
230 }
231
232 visitor->endVisit(this);
233 }
234
accept0(Visitor * visitor)235 void FieldMemberExpression::accept0(Visitor *visitor)
236 {
237 if (visitor->visit(this)) {
238 acceptChild(base, visitor);
239 }
240
241 visitor->endVisit(this);
242 }
243
accept0(Visitor * visitor)244 void NewMemberExpression::accept0(Visitor *visitor)
245 {
246 if (visitor->visit(this)) {
247 acceptChild(base, visitor);
248 acceptChild(arguments, visitor);
249 }
250
251 visitor->endVisit(this);
252 }
253
accept0(Visitor * visitor)254 void NewExpression::accept0(Visitor *visitor)
255 {
256 if (visitor->visit(this)) {
257 acceptChild(expression, visitor);
258 }
259
260 visitor->endVisit(this);
261 }
262
accept0(Visitor * visitor)263 void CallExpression::accept0(Visitor *visitor)
264 {
265 if (visitor->visit(this)) {
266 acceptChild(base, visitor);
267 acceptChild(arguments, visitor);
268 }
269
270 visitor->endVisit(this);
271 }
272
accept0(Visitor * visitor)273 void ArgumentList::accept0(Visitor *visitor)
274 {
275 if (visitor->visit(this)) {
276 ArgumentList *it = this;
277 do {
278 acceptChild(it->expression, visitor);
279 it = it->next;
280 } while (it);
281 }
282
283 visitor->endVisit(this);
284 }
285
accept0(Visitor * visitor)286 void PostIncrementExpression::accept0(Visitor *visitor)
287 {
288 if (visitor->visit(this)) {
289 acceptChild(base, visitor);
290 }
291
292 visitor->endVisit(this);
293 }
294
accept0(Visitor * visitor)295 void PostDecrementExpression::accept0(Visitor *visitor)
296 {
297 if (visitor->visit(this)) {
298 acceptChild(base, visitor);
299 }
300
301 visitor->endVisit(this);
302 }
303
accept0(Visitor * visitor)304 void DeleteExpression::accept0(Visitor *visitor)
305 {
306 if (visitor->visit(this)) {
307 acceptChild(expression, visitor);
308 }
309
310 visitor->endVisit(this);
311 }
312
accept0(Visitor * visitor)313 void VoidExpression::accept0(Visitor *visitor)
314 {
315 if (visitor->visit(this)) {
316 acceptChild(expression, visitor);
317 }
318
319 visitor->endVisit(this);
320 }
321
accept0(Visitor * visitor)322 void TypeOfExpression::accept0(Visitor *visitor)
323 {
324 if (visitor->visit(this)) {
325 acceptChild(expression, visitor);
326 }
327
328 visitor->endVisit(this);
329 }
330
accept0(Visitor * visitor)331 void PreIncrementExpression::accept0(Visitor *visitor)
332 {
333 if (visitor->visit(this)) {
334 acceptChild(expression, visitor);
335 }
336
337 visitor->endVisit(this);
338 }
339
accept0(Visitor * visitor)340 void PreDecrementExpression::accept0(Visitor *visitor)
341 {
342 if (visitor->visit(this)) {
343 acceptChild(expression, visitor);
344 }
345
346 visitor->endVisit(this);
347 }
348
accept0(Visitor * visitor)349 void UnaryPlusExpression::accept0(Visitor *visitor)
350 {
351 if (visitor->visit(this)) {
352 acceptChild(expression, visitor);
353 }
354
355 visitor->endVisit(this);
356 }
357
accept0(Visitor * visitor)358 void UnaryMinusExpression::accept0(Visitor *visitor)
359 {
360 if (visitor->visit(this)) {
361 acceptChild(expression, visitor);
362 }
363
364 visitor->endVisit(this);
365 }
366
accept0(Visitor * visitor)367 void TildeExpression::accept0(Visitor *visitor)
368 {
369 if (visitor->visit(this)) {
370 acceptChild(expression, visitor);
371 }
372
373 visitor->endVisit(this);
374 }
375
accept0(Visitor * visitor)376 void NotExpression::accept0(Visitor *visitor)
377 {
378 if (visitor->visit(this)) {
379 acceptChild(expression, visitor);
380 }
381
382 visitor->endVisit(this);
383 }
384
accept0(Visitor * visitor)385 void BinaryExpression::accept0(Visitor *visitor)
386 {
387 if (visitor->visit(this)) {
388 acceptChild(left, visitor);
389 acceptChild(right, visitor);
390 }
391
392 visitor->endVisit(this);
393 }
394
accept0(Visitor * visitor)395 void ConditionalExpression::accept0(Visitor *visitor)
396 {
397 if (visitor->visit(this)) {
398 acceptChild(expression, visitor);
399 acceptChild(ok, visitor);
400 acceptChild(ko, visitor);
401 }
402
403 visitor->endVisit(this);
404 }
405
accept0(Visitor * visitor)406 void Expression::accept0(Visitor *visitor)
407 {
408 if (visitor->visit(this)) {
409 acceptChild(left, visitor);
410 acceptChild(right, visitor);
411 }
412
413 visitor->endVisit(this);
414 }
415
accept0(Visitor * visitor)416 void Block::accept0(Visitor *visitor)
417 {
418 if (visitor->visit(this)) {
419 acceptChild(statements, visitor);
420 }
421
422 visitor->endVisit(this);
423 }
424
accept0(Visitor * visitor)425 void StatementList::accept0(Visitor *visitor)
426 {
427 if (visitor->visit(this)) {
428 StatementList *it = this;
429 do {
430 acceptChild(it->statement, visitor);
431 it = it->next;
432 } while (it);
433 }
434
435 visitor->endVisit(this);
436 }
437
accept0(Visitor * visitor)438 void VariableStatement::accept0(Visitor *visitor)
439 {
440 if (visitor->visit(this)) {
441 acceptChild(declarations, visitor);
442 }
443
444 visitor->endVisit(this);
445 }
446
accept0(Visitor * visitor)447 void VariableDeclarationList::accept0(Visitor *visitor)
448 {
449 if (visitor->visit(this)) {
450 VariableDeclarationList *it = this;
451 do {
452 acceptChild(it->declaration, visitor);
453 it = it->next;
454 } while (it);
455 }
456
457 visitor->endVisit(this);
458 }
459
accept0(Visitor * visitor)460 void VariableDeclaration::accept0(Visitor *visitor)
461 {
462 if (visitor->visit(this)) {
463 acceptChild(expression, visitor);
464 }
465
466 visitor->endVisit(this);
467 }
468
accept0(Visitor * visitor)469 void EmptyStatement::accept0(Visitor *visitor)
470 {
471 if (visitor->visit(this)) {
472 }
473
474 visitor->endVisit(this);
475 }
476
accept0(Visitor * visitor)477 void ExpressionStatement::accept0(Visitor *visitor)
478 {
479 if (visitor->visit(this)) {
480 acceptChild(expression, visitor);
481 }
482
483 visitor->endVisit(this);
484 }
485
accept0(Visitor * visitor)486 void IfStatement::accept0(Visitor *visitor)
487 {
488 if (visitor->visit(this)) {
489 acceptChild(expression, visitor);
490 acceptChild(ok, visitor);
491 acceptChild(ko, visitor);
492 }
493
494 visitor->endVisit(this);
495 }
496
accept0(Visitor * visitor)497 void DoWhileStatement::accept0(Visitor *visitor)
498 {
499 if (visitor->visit(this)) {
500 acceptChild(statement, visitor);
501 acceptChild(expression, visitor);
502 }
503
504 visitor->endVisit(this);
505 }
506
accept0(Visitor * visitor)507 void WhileStatement::accept0(Visitor *visitor)
508 {
509 if (visitor->visit(this)) {
510 acceptChild(expression, visitor);
511 acceptChild(statement, visitor);
512 }
513
514 visitor->endVisit(this);
515 }
516
accept0(Visitor * visitor)517 void ForStatement::accept0(Visitor *visitor)
518 {
519 if (visitor->visit(this)) {
520 acceptChild(initialiser, visitor);
521 acceptChild(condition, visitor);
522 acceptChild(expression, visitor);
523 acceptChild(statement, visitor);
524 }
525
526 visitor->endVisit(this);
527 }
528
accept0(Visitor * visitor)529 void LocalForStatement::accept0(Visitor *visitor)
530 {
531 if (visitor->visit(this)) {
532 acceptChild(declarations, visitor);
533 acceptChild(condition, visitor);
534 acceptChild(expression, visitor);
535 acceptChild(statement, visitor);
536 }
537
538 visitor->endVisit(this);
539 }
540
accept0(Visitor * visitor)541 void ForEachStatement::accept0(Visitor *visitor)
542 {
543 if (visitor->visit(this)) {
544 acceptChild(initialiser, visitor);
545 acceptChild(expression, visitor);
546 acceptChild(statement, visitor);
547 }
548
549 visitor->endVisit(this);
550 }
551
accept0(Visitor * visitor)552 void LocalForEachStatement::accept0(Visitor *visitor)
553 {
554 if (visitor->visit(this)) {
555 acceptChild(declaration, visitor);
556 acceptChild(expression, visitor);
557 acceptChild(statement, visitor);
558 }
559
560 visitor->endVisit(this);
561 }
562
accept0(Visitor * visitor)563 void ContinueStatement::accept0(Visitor *visitor)
564 {
565 if (visitor->visit(this)) {
566 }
567
568 visitor->endVisit(this);
569 }
570
accept0(Visitor * visitor)571 void BreakStatement::accept0(Visitor *visitor)
572 {
573 if (visitor->visit(this)) {
574 }
575
576 visitor->endVisit(this);
577 }
578
accept0(Visitor * visitor)579 void ReturnStatement::accept0(Visitor *visitor)
580 {
581 if (visitor->visit(this)) {
582 acceptChild(expression, visitor);
583 }
584
585 visitor->endVisit(this);
586 }
587
accept0(Visitor * visitor)588 void WithStatement::accept0(Visitor *visitor)
589 {
590 if (visitor->visit(this)) {
591 acceptChild(expression, visitor);
592 acceptChild(statement, visitor);
593 }
594
595 visitor->endVisit(this);
596 }
597
accept0(Visitor * visitor)598 void SwitchStatement::accept0(Visitor *visitor)
599 {
600 if (visitor->visit(this)) {
601 acceptChild(expression, visitor);
602 acceptChild(block, visitor);
603 }
604
605 visitor->endVisit(this);
606 }
607
accept0(Visitor * visitor)608 void CaseBlock::accept0(Visitor *visitor)
609 {
610 if (visitor->visit(this)) {
611 acceptChild(clauses, visitor);
612 acceptChild(defaultClause, visitor);
613 acceptChild(moreClauses, visitor);
614 }
615
616 visitor->endVisit(this);
617 }
618
accept0(Visitor * visitor)619 void CaseClauses::accept0(Visitor *visitor)
620 {
621 if (visitor->visit(this)) {
622 CaseClauses *it = this;
623 do {
624 acceptChild(it->clause, visitor);
625 it = it->next;
626 } while (it);
627 }
628
629 visitor->endVisit(this);
630 }
631
accept0(Visitor * visitor)632 void CaseClause::accept0(Visitor *visitor)
633 {
634 if (visitor->visit(this)) {
635 acceptChild(expression, visitor);
636 acceptChild(statements, visitor);
637 }
638
639 visitor->endVisit(this);
640 }
641
accept0(Visitor * visitor)642 void DefaultClause::accept0(Visitor *visitor)
643 {
644 if (visitor->visit(this)) {
645 acceptChild(statements, visitor);
646 }
647
648 visitor->endVisit(this);
649 }
650
accept0(Visitor * visitor)651 void LabelledStatement::accept0(Visitor *visitor)
652 {
653 if (visitor->visit(this)) {
654 acceptChild(statement, visitor);
655 }
656
657 visitor->endVisit(this);
658 }
659
accept0(Visitor * visitor)660 void ThrowStatement::accept0(Visitor *visitor)
661 {
662 if (visitor->visit(this)) {
663 acceptChild(expression, visitor);
664 }
665
666 visitor->endVisit(this);
667 }
668
accept0(Visitor * visitor)669 void TryStatement::accept0(Visitor *visitor)
670 {
671 if (visitor->visit(this)) {
672 acceptChild(statement, visitor);
673 acceptChild(catchExpression, visitor);
674 acceptChild(finallyExpression, visitor);
675 }
676
677 visitor->endVisit(this);
678 }
679
accept0(Visitor * visitor)680 void Catch::accept0(Visitor *visitor)
681 {
682 if (visitor->visit(this)) {
683 acceptChild(statement, visitor);
684 }
685
686 visitor->endVisit(this);
687 }
688
accept0(Visitor * visitor)689 void Finally::accept0(Visitor *visitor)
690 {
691 if (visitor->visit(this)) {
692 acceptChild(statement, visitor);
693 }
694
695 visitor->endVisit(this);
696 }
697
accept0(Visitor * visitor)698 void FunctionDeclaration::accept0(Visitor *visitor)
699 {
700 if (visitor->visit(this)) {
701 acceptChild(formals, visitor);
702 acceptChild(body, visitor);
703 }
704
705 visitor->endVisit(this);
706 }
707
accept0(Visitor * visitor)708 void FunctionExpression::accept0(Visitor *visitor)
709 {
710 if (visitor->visit(this)) {
711 acceptChild(formals, visitor);
712 acceptChild(body, visitor);
713 }
714
715 visitor->endVisit(this);
716 }
717
accept0(Visitor * visitor)718 void FormalParameterList::accept0(Visitor *visitor)
719 {
720 if (visitor->visit(this)) {
721 // ###
722 }
723
724 visitor->endVisit(this);
725 }
726
accept0(Visitor * visitor)727 void FunctionBody::accept0(Visitor *visitor)
728 {
729 if (visitor->visit(this)) {
730 acceptChild(elements, visitor);
731 }
732
733 visitor->endVisit(this);
734 }
735
accept0(Visitor * visitor)736 void Program::accept0(Visitor *visitor)
737 {
738 if (visitor->visit(this)) {
739 acceptChild(elements, visitor);
740 }
741
742 visitor->endVisit(this);
743 }
744
accept0(Visitor * visitor)745 void SourceElements::accept0(Visitor *visitor)
746 {
747 if (visitor->visit(this)) {
748 SourceElements *it = this;
749 do {
750 acceptChild(it->element, visitor);
751 it = it->next;
752 } while (it);
753 }
754
755 visitor->endVisit(this);
756 }
757
accept0(Visitor * visitor)758 void FunctionSourceElement::accept0(Visitor *visitor)
759 {
760 if (visitor->visit(this)) {
761 acceptChild(declaration, visitor);
762 }
763
764 visitor->endVisit(this);
765 }
766
accept0(Visitor * visitor)767 void StatementSourceElement::accept0(Visitor *visitor)
768 {
769 if (visitor->visit(this)) {
770 acceptChild(statement, visitor);
771 }
772
773 visitor->endVisit(this);
774 }
775
accept0(Visitor * visitor)776 void DebuggerStatement::accept0(Visitor *visitor)
777 {
778 if (visitor->visit(this)) {
779 }
780
781 visitor->endVisit(this);
782 }
783
784 } } // namespace QScript::AST
785
786 QT_END_NAMESPACE
787
788