~ubuntu-branches/ubuntu/utopic/kdevelop-php/utopic
» Revision
1
: parser/generated/phpdefaultvisitor.cpp
« back to all changes in this revision
Viewing changes to parser/generated/phpdefaultvisitor.cpp
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Fathi Boudra
- Date: 2010-01-17 17:10:22 UTC
- Revision ID: james.westby@ubuntu.com-20100117171022-q2xlgd9ekewo2ijx
Tags: upstream-1.0.0~beta2
Import upstream version 1.0.0~beta2
- files added:
- app_templates
- app_templates/simple_phpapp
- cmake
- completion
- completion/tests
- duchain
- duchain/navigation
- duchain/tests
- parser
- parser/generated
- parser/generated/kdevelop-pg-qt
- parser/test
added
removed
parser/generated/phpdefaultvisitor.cpp
1
// THIS FILE IS GENERATED
2
// WARNING! All changes made in this file will be lost!
3
4
#include "phpdefaultvisitor.h"
5
6
namespace Php
7
{
8
9
void DefaultVisitor::visitAdditiveExpression(AdditiveExpressionAst *node)
10
{
11
visitNode(node->expression);
12
if (node->additionalExpressionSequence)
13
{
14
const KDevPG::ListNode<AdditiveExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
15
do
16
{
17
visitNode(__it->element);
18
__it = __it->next;
19
}
20
while (__it != __end);
21
}
22
}
23
24
void DefaultVisitor::visitAdditiveExpressionRest(AdditiveExpressionRestAst *node)
25
{
26
visitNode(node->expression);
27
}
28
29
void DefaultVisitor::visitArrayPairValue(ArrayPairValueAst *node)
30
{
31
visitNode(node->expr);
32
visitNode(node->exprValue);
33
visitNode(node->varValue);
34
visitNode(node->variable);
35
}
36
37
void DefaultVisitor::visitAssignmentExpression(AssignmentExpressionAst *node)
38
{
39
visitNode(node->expression);
40
visitNode(node->assignmentExpressionEqual);
41
visitNode(node->assignmentExpression);
42
}
43
44
void DefaultVisitor::visitAssignmentExpressionCheckIfVariable(AssignmentExpressionCheckIfVariableAst *)
45
{
46
}
47
48
void DefaultVisitor::visitAssignmentExpressionEqual(AssignmentExpressionEqualAst *node)
49
{
50
visitNode(node->assignmentExpression);
51
}
52
53
void DefaultVisitor::visitAssignmentList(AssignmentListAst *node)
54
{
55
if (node->elementSequence)
56
{
57
const KDevPG::ListNode<AssignmentListElementAst*> *__it = node->elementSequence->front(), *__end = __it;
58
do
59
{
60
visitNode(__it->element);
61
__it = __it->next;
62
}
63
while (__it != __end);
64
}
65
}
66
67
void DefaultVisitor::visitAssignmentListElement(AssignmentListElementAst *node)
68
{
69
visitNode(node->variable);
70
visitNode(node->assignmentList);
71
}
72
73
void DefaultVisitor::visitBaseVariable(BaseVariableAst *node)
74
{
75
visitNode(node->var);
76
if (node->offsetItemsSequence)
77
{
78
const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
79
do
80
{
81
visitNode(__it->element);
82
__it = __it->next;
83
}
84
while (__it != __end);
85
}
86
visitNode(node->staticMember);
87
}
88
89
void DefaultVisitor::visitBaseVariableWithFunctionCalls(BaseVariableWithFunctionCallsAst *node)
90
{
91
visitNode(node->functionCall);
92
visitNode(node->baseVariable);
93
}
94
95
void DefaultVisitor::visitBitAndExpression(BitAndExpressionAst *node)
96
{
97
if (node->expressionSequence)
98
{
99
const KDevPG::ListNode<EqualityExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
100
do
101
{
102
visitNode(__it->element);
103
__it = __it->next;
104
}
105
while (__it != __end);
106
}
107
}
108
109
void DefaultVisitor::visitBitOrExpression(BitOrExpressionAst *node)
110
{
111
if (node->expressionSequence)
112
{
113
const KDevPG::ListNode<BitXorExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
114
do
115
{
116
visitNode(__it->element);
117
__it = __it->next;
118
}
119
while (__it != __end);
120
}
121
}
122
123
void DefaultVisitor::visitBitXorExpression(BitXorExpressionAst *node)
124
{
125
if (node->expressionSequence)
126
{
127
const KDevPG::ListNode<BitAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
128
do
129
{
130
visitNode(__it->element);
131
__it = __it->next;
132
}
133
while (__it != __end);
134
}
135
}
136
137
void DefaultVisitor::visitBooleanAndExpression(BooleanAndExpressionAst *node)
138
{
139
if (node->expressionSequence)
140
{
141
const KDevPG::ListNode<BitOrExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
142
do
143
{
144
visitNode(__it->element);
145
__it = __it->next;
146
}
147
while (__it != __end);
148
}
149
}
150
151
void DefaultVisitor::visitBooleanOrExpression(BooleanOrExpressionAst *node)
152
{
153
if (node->expressionSequence)
154
{
155
const KDevPG::ListNode<BooleanAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
156
do
157
{
158
visitNode(__it->element);
159
__it = __it->next;
160
}
161
while (__it != __end);
162
}
163
}
164
165
void DefaultVisitor::visitCaseList(CaseListAst *node)
166
{
167
if (node->caseItemsSequence)
168
{
169
const KDevPG::ListNode<Case_itemAst*> *__it = node->caseItemsSequence->front(), *__end = __it;
170
do
171
{
172
visitNode(__it->element);
173
__it = __it->next;
174
}
175
while (__it != __end);
176
}
177
}
178
179
void DefaultVisitor::visitCase_item(Case_itemAst *node)
180
{
181
visitNode(node->expr);
182
visitNode(node->statements);
183
}
184
185
void DefaultVisitor::visitCatchItem(CatchItemAst *node)
186
{
187
visitNode(node->catchClass);
188
visitNode(node->var);
189
visitNode(node->statements);
190
}
191
192
void DefaultVisitor::visitClassBody(ClassBodyAst *node)
193
{
194
if (node->classStatementsSequence)
195
{
196
const KDevPG::ListNode<ClassStatementAst*> *__it = node->classStatementsSequence->front(), *__end = __it;
197
do
198
{
199
visitNode(__it->element);
200
__it = __it->next;
201
}
202
while (__it != __end);
203
}
204
}
205
206
void DefaultVisitor::visitClassConstantDeclaration(ClassConstantDeclarationAst *node)
207
{
208
visitNode(node->identifier);
209
visitNode(node->scalar);
210
}
211
212
void DefaultVisitor::visitClassDeclarationStatement(ClassDeclarationStatementAst *node)
213
{
214
visitNode(node->modifier);
215
visitNode(node->className);
216
visitNode(node->extends);
217
visitNode(node->implements);
218
visitNode(node->body);
219
}
220
221
void DefaultVisitor::visitClassExtends(ClassExtendsAst *node)
222
{
223
visitNode(node->identifier);
224
}
225
226
void DefaultVisitor::visitClassImplements(ClassImplementsAst *node)
227
{
228
if (node->implementsSequence)
229
{
230
const KDevPG::ListNode<IdentifierAst*> *__it = node->implementsSequence->front(), *__end = __it;
231
do
232
{
233
visitNode(__it->element);
234
__it = __it->next;
235
}
236
while (__it != __end);
237
}
238
}
239
240
void DefaultVisitor::visitClassNameReference(ClassNameReferenceAst *node)
241
{
242
visitNode(node->identifier);
243
visitNode(node->dynamicClassNameReference);
244
}
245
246
void DefaultVisitor::visitClassStatement(ClassStatementAst *node)
247
{
248
visitNode(node->consts);
249
visitNode(node->variable);
250
visitNode(node->modifiers);
251
visitNode(node->methodName);
252
visitNode(node->parameters);
253
visitNode(node->methodBody);
254
}
255
256
void DefaultVisitor::visitClassVariable(ClassVariableAst *node)
257
{
258
visitNode(node->variable);
259
visitNode(node->value);
260
}
261
262
void DefaultVisitor::visitClassVariableDeclaration(ClassVariableDeclarationAst *node)
263
{
264
if (node->varsSequence)
265
{
266
const KDevPG::ListNode<ClassVariableAst*> *__it = node->varsSequence->front(), *__end = __it;
267
do
268
{
269
visitNode(__it->element);
270
__it = __it->next;
271
}
272
while (__it != __end);
273
}
274
}
275
276
void DefaultVisitor::visitCommonScalar(CommonScalarAst *)
277
{
278
}
279
280
void DefaultVisitor::visitCompoundVariable(CompoundVariableAst *node)
281
{
282
visitNode(node->variable);
283
visitNode(node->expr);
284
}
285
286
void DefaultVisitor::visitCompoundVariableWithSimpleIndirectReference(CompoundVariableWithSimpleIndirectReferenceAst *node)
287
{
288
visitNode(node->indirectVariable);
289
visitNode(node->expr);
290
visitNode(node->variable);
291
}
292
293
void DefaultVisitor::visitConditionalExpression(ConditionalExpressionAst *node)
294
{
295
visitNode(node->expression);
296
visitNode(node->ifExpression);
297
visitNode(node->elseExpression);
298
}
299
300
void DefaultVisitor::visitConstantOrClassConst(ConstantOrClassConstAst *node)
301
{
302
visitNode(node->className);
303
visitNode(node->constant);
304
}
305
306
void DefaultVisitor::visitCtorArguments(CtorArgumentsAst *node)
307
{
308
visitNode(node->parameterList);
309
}
310
311
void DefaultVisitor::visitDeclareItem(DeclareItemAst *node)
312
{
313
visitNode(node->scalar);
314
}
315
316
void DefaultVisitor::visitDeclareStatement(DeclareStatementAst *node)
317
{
318
visitNode(node->statement);
319
visitNode(node->statements);
320
}
321
322
void DefaultVisitor::visitDimListItem(DimListItemAst *node)
323
{
324
visitNode(node->dimOffset);
325
visitNode(node->expr);
326
}
327
328
void DefaultVisitor::visitDimOffset(DimOffsetAst *node)
329
{
330
visitNode(node->expr);
331
}
332
333
void DefaultVisitor::visitDynamicClassNameReference(DynamicClassNameReferenceAst *node)
334
{
335
visitNode(node->baseVariable);
336
visitNode(node->objectProperty);
337
visitNode(node->properties);
338
}
339
340
void DefaultVisitor::visitDynamicClassNameVariableProperties(DynamicClassNameVariablePropertiesAst *node)
341
{
342
if (node->propertiesSequence)
343
{
344
const KDevPG::ListNode<DynamicClassNameVariablePropertyAst*> *__it = node->propertiesSequence->front(), *__end = __it;
345
do
346
{
347
visitNode(__it->element);
348
__it = __it->next;
349
}
350
while (__it != __end);
351
}
352
}
353
354
void DefaultVisitor::visitDynamicClassNameVariableProperty(DynamicClassNameVariablePropertyAst *node)
355
{
356
visitNode(node->property);
357
}
358
359
void DefaultVisitor::visitElseSingle(ElseSingleAst *node)
360
{
361
visitNode(node->statement);
362
}
363
364
void DefaultVisitor::visitElseifList(ElseifListAst *node)
365
{
366
if (node->elseifListItemSequence)
367
{
368
const KDevPG::ListNode<ElseifListItemAst*> *__it = node->elseifListItemSequence->front(), *__end = __it;
369
do
370
{
371
visitNode(__it->element);
372
__it = __it->next;
373
}
374
while (__it != __end);
375
}
376
}
377
378
void DefaultVisitor::visitElseifListItem(ElseifListItemAst *node)
379
{
380
visitNode(node->expr);
381
visitNode(node->statement);
382
}
383
384
void DefaultVisitor::visitEncaps(EncapsAst *node)
385
{
386
visitNode(node->var);
387
}
388
389
void DefaultVisitor::visitEncapsList(EncapsListAst *node)
390
{
391
if (node->encapsSequence)
392
{
393
const KDevPG::ListNode<EncapsAst*> *__it = node->encapsSequence->front(), *__end = __it;
394
do
395
{
396
visitNode(__it->element);
397
__it = __it->next;
398
}
399
while (__it != __end);
400
}
401
}
402
403
void DefaultVisitor::visitEncapsVar(EncapsVarAst *node)
404
{
405
visitNode(node->expr);
406
visitNode(node->variable);
407
visitNode(node->propertyIdentifier);
408
visitNode(node->offset);
409
}
410
411
void DefaultVisitor::visitEncapsVarOffset(EncapsVarOffsetAst *)
412
{
413
}
414
415
void DefaultVisitor::visitEqualityExpression(EqualityExpressionAst *node)
416
{
417
visitNode(node->expression);
418
if (node->additionalExpressionSequence)
419
{
420
const KDevPG::ListNode<EqualityExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
421
do
422
{
423
visitNode(__it->element);
424
__it = __it->next;
425
}
426
while (__it != __end);
427
}
428
}
429
430
void DefaultVisitor::visitEqualityExpressionRest(EqualityExpressionRestAst *node)
431
{
432
visitNode(node->expression);
433
}
434
435
void DefaultVisitor::visitExpr(ExprAst *node)
436
{
437
visitNode(node->expression);
438
}
439
440
void DefaultVisitor::visitForExpr(ForExprAst *node)
441
{
442
if (node->exprsSequence)
443
{
444
const KDevPG::ListNode<ExprAst*> *__it = node->exprsSequence->front(), *__end = __it;
445
do
446
{
447
visitNode(__it->element);
448
__it = __it->next;
449
}
450
while (__it != __end);
451
}
452
}
453
454
void DefaultVisitor::visitForStatement(ForStatementAst *node)
455
{
456
visitNode(node->statement);
457
visitNode(node->statements);
458
}
459
460
void DefaultVisitor::visitForeachStatement(ForeachStatementAst *node)
461
{
462
visitNode(node->statement);
463
visitNode(node->statements);
464
}
465
466
void DefaultVisitor::visitForeachVariable(ForeachVariableAst *node)
467
{
468
visitNode(node->variable);
469
}
470
471
void DefaultVisitor::visitFunctionCall(FunctionCallAst *node)
472
{
473
visitNode(node->stringFunctionNameOrClass);
474
visitNode(node->stringParameterList);
475
visitNode(node->stringFunctionName);
476
visitNode(node->varFunctionName);
477
visitNode(node->varParameterList);
478
}
479
480
void DefaultVisitor::visitFunctionCallParameterList(FunctionCallParameterListAst *node)
481
{
482
if (node->parametersSequence)
483
{
484
const KDevPG::ListNode<FunctionCallParameterListElementAst*> *__it = node->parametersSequence->front(), *__end = __it;
485
do
486
{
487
visitNode(__it->element);
488
__it = __it->next;
489
}
490
while (__it != __end);
491
}
492
}
493
494
void DefaultVisitor::visitFunctionCallParameterListElement(FunctionCallParameterListElementAst *node)
495
{
496
visitNode(node->variable);
497
visitNode(node->expr);
498
}
499
500
void DefaultVisitor::visitFunctionDeclarationStatement(FunctionDeclarationStatementAst *node)
501
{
502
visitNode(node->functionName);
503
visitNode(node->parameters);
504
visitNode(node->functionBody);
505
}
506
507
void DefaultVisitor::visitGlobalVar(GlobalVarAst *node)
508
{
509
visitNode(node->var);
510
visitNode(node->dollarVar);
511
visitNode(node->expr);
512
}
513
514
void DefaultVisitor::visitIdentifier(IdentifierAst *)
515
{
516
}
517
518
void DefaultVisitor::visitInnerStatementList(InnerStatementListAst *node)
519
{
520
if (node->statementsSequence)
521
{
522
const KDevPG::ListNode<TopStatementAst*> *__it = node->statementsSequence->front(), *__end = __it;
523
do
524
{
525
visitNode(__it->element);
526
__it = __it->next;
527
}
528
while (__it != __end);
529
}
530
}
531
532
void DefaultVisitor::visitInterfaceDeclarationStatement(InterfaceDeclarationStatementAst *node)
533
{
534
visitNode(node->interfaceName);
535
visitNode(node->extends);
536
visitNode(node->body);
537
}
538
539
void DefaultVisitor::visitLogicalAndExpression(LogicalAndExpressionAst *node)
540
{
541
if (node->expressionSequence)
542
{
543
const KDevPG::ListNode<PrintExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
544
do
545
{
546
visitNode(__it->element);
547
__it = __it->next;
548
}
549
while (__it != __end);
550
}
551
}
552
553
void DefaultVisitor::visitLogicalOrExpression(LogicalOrExpressionAst *node)
554
{
555
if (node->expressionSequence)
556
{
557
const KDevPG::ListNode<LogicalXorExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
558
do
559
{
560
visitNode(__it->element);
561
__it = __it->next;
562
}
563
while (__it != __end);
564
}
565
}
566
567
void DefaultVisitor::visitLogicalXorExpression(LogicalXorExpressionAst *node)
568
{
569
if (node->expressionSequence)
570
{
571
const KDevPG::ListNode<LogicalAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
572
do
573
{
574
visitNode(__it->element);
575
__it = __it->next;
576
}
577
while (__it != __end);
578
}
579
}
580
581
void DefaultVisitor::visitMethodBody(MethodBodyAst *node)
582
{
583
visitNode(node->statements);
584
}
585
586
void DefaultVisitor::visitMultiplicativeExpression(MultiplicativeExpressionAst *node)
587
{
588
visitNode(node->expression);
589
if (node->additionalExpressionSequence)
590
{
591
const KDevPG::ListNode<MultiplicativeExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
592
do
593
{
594
visitNode(__it->element);
595
__it = __it->next;
596
}
597
while (__it != __end);
598
}
599
}
600
601
void DefaultVisitor::visitMultiplicativeExpressionRest(MultiplicativeExpressionRestAst *node)
602
{
603
visitNode(node->expression);
604
}
605
606
void DefaultVisitor::visitNewElseSingle(NewElseSingleAst *node)
607
{
608
visitNode(node->statements);
609
}
610
611
void DefaultVisitor::visitNewElseifList(NewElseifListAst *node)
612
{
613
if (node->newElseifListItemSequence)
614
{
615
const KDevPG::ListNode<NewelseifListItemAst*> *__it = node->newElseifListItemSequence->front(), *__end = __it;
616
do
617
{
618
visitNode(__it->element);
619
__it = __it->next;
620
}
621
while (__it != __end);
622
}
623
}
624
625
void DefaultVisitor::visitNewelseifListItem(NewelseifListItemAst *node)
626
{
627
visitNode(node->expr);
628
visitNode(node->statements);
629
}
630
631
void DefaultVisitor::visitObjectDimList(ObjectDimListAst *node)
632
{
633
visitNode(node->variableName);
634
if (node->offsetItemsSequence)
635
{
636
const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
637
do
638
{
639
visitNode(__it->element);
640
__it = __it->next;
641
}
642
while (__it != __end);
643
}
644
}
645
646
void DefaultVisitor::visitObjectProperty(ObjectPropertyAst *node)
647
{
648
visitNode(node->objectDimList);
649
visitNode(node->variableWithoutObjects);
650
}
651
652
void DefaultVisitor::visitOptionalClassModifier(OptionalClassModifierAst *)
653
{
654
}
655
656
void DefaultVisitor::visitOptionalModifiers(OptionalModifiersAst *)
657
{
658
}
659
660
void DefaultVisitor::visitParameter(ParameterAst *node)
661
{
662
visitNode(node->parameterType);
663
visitNode(node->variable);
664
visitNode(node->defaultValue);
665
}
666
667
void DefaultVisitor::visitParameterList(ParameterListAst *node)
668
{
669
if (node->parametersSequence)
670
{
671
const KDevPG::ListNode<ParameterAst*> *__it = node->parametersSequence->front(), *__end = __it;
672
do
673
{
674
visitNode(__it->element);
675
__it = __it->next;
676
}
677
while (__it != __end);
678
}
679
}
680
681
void DefaultVisitor::visitPostprefixOperator(PostprefixOperatorAst *)
682
{
683
}
684
685
void DefaultVisitor::visitPrintExpression(PrintExpressionAst *node)
686
{
687
visitNode(node->expression);
688
}
689
690
void DefaultVisitor::visitRelationalExpression(RelationalExpressionAst *node)
691
{
692
visitNode(node->expression);
693
if (node->additionalExpressionSequence)
694
{
695
const KDevPG::ListNode<RelationalExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
696
do
697
{
698
visitNode(__it->element);
699
__it = __it->next;
700
}
701
while (__it != __end);
702
}
703
visitNode(node->instanceofType);
704
}
705
706
void DefaultVisitor::visitRelationalExpressionRest(RelationalExpressionRestAst *node)
707
{
708
visitNode(node->expression);
709
}
710
711
void DefaultVisitor::visitScalar(ScalarAst *node)
712
{
713
visitNode(node->commonScalar);
714
visitNode(node->constantOrClassConst);
715
visitNode(node->encapsList);
716
}
717
718
void DefaultVisitor::visitSemicolonOrCloseTag(SemicolonOrCloseTagAst *)
719
{
720
}
721
722
void DefaultVisitor::visitShiftExpression(ShiftExpressionAst *node)
723
{
724
visitNode(node->expression);
725
if (node->additionalExpressionSequence)
726
{
727
const KDevPG::ListNode<ShiftExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
728
do
729
{
730
visitNode(__it->element);
731
__it = __it->next;
732
}
733
while (__it != __end);
734
}
735
}
736
737
void DefaultVisitor::visitShiftExpressionRest(ShiftExpressionRestAst *node)
738
{
739
visitNode(node->expression);
740
}
741
742
void DefaultVisitor::visitStart(StartAst *node)
743
{
744
visitNode(node->statements);
745
}
746
747
void DefaultVisitor::visitStatement(StatementAst *node)
748
{
749
visitNode(node->statements);
750
visitNode(node->ifExpr);
751
visitNode(node->ifStatement);
752
visitNode(node->elseifList);
753
visitNode(node->elseSingle);
754
visitNode(node->whileExpr);
755
visitNode(node->whilteStatement);
756
visitNode(node->forExpr1);
757
visitNode(node->forExpr2);
758
visitNode(node->forExpr3);
759
visitNode(node->forStatement);
760
visitNode(node->swtichExpr);
761
visitNode(node->switchCaseList);
762
visitNode(node->foreachVar);
763
visitNode(node->foreachVarAsVar);
764
visitNode(node->foreachExpr);
765
visitNode(node->foreachExprAsVar);
766
visitNode(node->foreachVariable);
767
visitNode(node->foreachStatement);
768
visitNode(node->declareItem);
769
if (node->catchesSequence)
770
{
771
const KDevPG::ListNode<CatchItemAst*> *__it = node->catchesSequence->front(), *__end = __it;
772
do
773
{
774
visitNode(__it->element);
775
__it = __it->next;
776
}
777
while (__it != __end);
778
}
779
if (node->unsetVariablesSequence)
780
{
781
const KDevPG::ListNode<VariableAst*> *__it = node->unsetVariablesSequence->front(), *__end = __it;
782
do
783
{
784
visitNode(__it->element);
785
__it = __it->next;
786
}
787
while (__it != __end);
788
}
789
visitNode(node->expr);
790
visitNode(node->doStatement);
791
visitNode(node->whilteExpr);
792
visitNode(node->breakExpr);
793
visitNode(node->continueExpr);
794
visitNode(node->returnExpr);
795
if (node->globalVarsSequence)
796
{
797
const KDevPG::ListNode<GlobalVarAst*> *__it = node->globalVarsSequence->front(), *__end = __it;
798
do
799
{
800
visitNode(__it->element);
801
__it = __it->next;
802
}
803
while (__it != __end);
804
}
805
if (node->staticVarsSequence)
806
{
807
const KDevPG::ListNode<StaticVarAst*> *__it = node->staticVarsSequence->front(), *__end = __it;
808
do
809
{
810
visitNode(__it->element);
811
__it = __it->next;
812
}
813
while (__it != __end);
814
}
815
if (node->echoExprsSequence)
816
{
817
const KDevPG::ListNode<ExprAst*> *__it = node->echoExprsSequence->front(), *__end = __it;
818
do
819
{
820
visitNode(__it->element);
821
__it = __it->next;
822
}
823
while (__it != __end);
824
}
825
visitNode(node->throwExpr);
826
}
827
828
void DefaultVisitor::visitStaticArrayPairValue(StaticArrayPairValueAst *node)
829
{
830
if (node->val1Sequence)
831
{
832
const KDevPG::ListNode<StaticScalarAst*> *__it = node->val1Sequence->front(), *__end = __it;
833
do
834
{
835
visitNode(__it->element);
836
__it = __it->next;
837
}
838
while (__it != __end);
839
}
840
if (node->val2Sequence)
841
{
842
const KDevPG::ListNode<StaticScalarAst*> *__it = node->val2Sequence->front(), *__end = __it;
843
do
844
{
845
visitNode(__it->element);
846
__it = __it->next;
847
}
848
while (__it != __end);
849
}
850
}
851
852
void DefaultVisitor::visitStaticMember(StaticMemberAst *node)
853
{
854
visitNode(node->className);
855
visitNode(node->variable);
856
}
857
858
void DefaultVisitor::visitStaticScalar(StaticScalarAst *node)
859
{
860
visitNode(node->value);
861
visitNode(node->constantOrClassConst);
862
visitNode(node->plusValue);
863
visitNode(node->minusValue);
864
if (node->arrayValuesSequence)
865
{
866
const KDevPG::ListNode<StaticArrayPairValueAst*> *__it = node->arrayValuesSequence->front(), *__end = __it;
867
do
868
{
869
visitNode(__it->element);
870
__it = __it->next;
871
}
872
while (__it != __end);
873
}
874
}
875
876
void DefaultVisitor::visitStaticVar(StaticVarAst *node)
877
{
878
visitNode(node->var);
879
visitNode(node->value);
880
}
881
882
void DefaultVisitor::visitSwitchCaseList(SwitchCaseListAst *node)
883
{
884
visitNode(node->caseList);
885
}
886
887
void DefaultVisitor::visitTopStatement(TopStatementAst *node)
888
{
889
visitNode(node->statement);
890
visitNode(node->functionDeclaration);
891
visitNode(node->classDeclaration);
892
visitNode(node->interfaceDeclaration);
893
}
894
895
void DefaultVisitor::visitUnaryExpression(UnaryExpressionAst *node)
896
{
897
visitNode(node->unaryExpression);
898
visitNode(node->assignmentList);
899
visitNode(node->expression);
900
visitNode(node->includeExpression);
901
visitNode(node->unaryExpressionNotPlusminus);
902
}
903
904
void DefaultVisitor::visitUnaryExpressionNotPlusminus(UnaryExpressionNotPlusminusAst *node)
905
{
906
if (node->prefixOperatorSequence)
907
{
908
const KDevPG::ListNode<PostprefixOperatorAst*> *__it = node->prefixOperatorSequence->front(), *__end = __it;
909
do
910
{
911
visitNode(__it->element);
912
__it = __it->next;
913
}
914
while (__it != __end);
915
}
916
visitNode(node->varExpression);
917
if (node->postfixOperatorSequence)
918
{
919
const KDevPG::ListNode<PostprefixOperatorAst*> *__it = node->postfixOperatorSequence->front(), *__end = __it;
920
do
921
{
922
visitNode(__it->element);
923
__it = __it->next;
924
}
925
while (__it != __end);
926
}
927
}
928
929
void DefaultVisitor::visitVarExpression(VarExpressionAst *node)
930
{
931
visitNode(node->variable);
932
visitNode(node->newObject);
933
visitNode(node->varExpressionNormal);
934
}
935
936
void DefaultVisitor::visitVarExpressionNewObject(VarExpressionNewObjectAst *node)
937
{
938
visitNode(node->className);
939
visitNode(node->ctor);
940
}
941
942
void DefaultVisitor::visitVarExpressionNormal(VarExpressionNormalAst *node)
943
{
944
visitNode(node->expression);
945
visitNode(node->encapsList);
946
visitNode(node->variable);
947
visitNode(node->scalar);
948
if (node->arrayValuesSequence)
949
{
950
const KDevPG::ListNode<ArrayPairValueAst*> *__it = node->arrayValuesSequence->front(), *__end = __it;
951
do
952
{
953
visitNode(__it->element);
954
__it = __it->next;
955
}
956
while (__it != __end);
957
}
958
if (node->issetVariableSequence)
959
{
960
const KDevPG::ListNode<VariableAst*> *__it = node->issetVariableSequence->front(), *__end = __it;
961
do
962
{
963
visitNode(__it->element);
964
__it = __it->next;
965
}
966
while (__it != __end);
967
}
968
visitNode(node->emptyVarialbe);
969
visitNode(node->newObject);
970
visitNode(node->cloneCar);
971
}
972
973
void DefaultVisitor::visitVariable(VariableAst *node)
974
{
975
visitNode(node->var);
976
if (node->variablePropertiesSequence)
977
{
978
const KDevPG::ListNode<VariablePropertyAst*> *__it = node->variablePropertiesSequence->front(), *__end = __it;
979
do
980
{
981
visitNode(__it->element);
982
__it = __it->next;
983
}
984
while (__it != __end);
985
}
986
}
987
988
void DefaultVisitor::visitVariableIdentifier(VariableIdentifierAst *)
989
{
990
}
991
992
void DefaultVisitor::visitVariableName(VariableNameAst *node)
993
{
994
visitNode(node->name);
995
visitNode(node->expr);
996
}
997
998
void DefaultVisitor::visitVariableProperty(VariablePropertyAst *node)
999
{
1000
visitNode(node->objectProperty);
1001
visitNode(node->parameterList);
1002
}
1003
1004
void DefaultVisitor::visitVariableWithoutObjects(VariableWithoutObjectsAst *node)
1005
{
1006
visitNode(node->variable);
1007
if (node->offsetItemsSequence)
1008
{
1009
const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
1010
do
1011
{
1012
visitNode(__it->element);
1013
__it = __it->next;
1014
}
1015
while (__it != __end);
1016
}
1017
}
1018
1019
void DefaultVisitor::visitWhileStatement(WhileStatementAst *node)
1020
{
1021
visitNode(node->statement);
1022
visitNode(node->statements);
1023
}
1024
1025
1026
} // end of namespace Php
1027
Loggerhead is a web-based interface for Breezy
Version: 2.0.1