← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kdevelop-php/utopic

« back to all changes in this revision

Viewing changes to parser/generated/phpdebugvisitor.h

  • 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

Show diffs side-by-side

added added

removed removed

Lines of Context:
parser/generated/phpdebugvisitor.h
 
1
// THIS FILE IS GENERATED
 
2
// WARNING! All changes made in this file will be lost!
 
3
 
 
4
#ifndef PHP_DEBUG_VISITOR_H_INCLUDED
 
5
#define PHP_DEBUG_VISITOR_H_INCLUDED
 
6
 
 
7
#include "phpdefaultvisitor.h"
 
8
 
 
9
#include <parserexport.h>
 
10
#include <kdev-pg-token-stream.h>
 
11
#include <QtCore/QTextStream>
 
12
#include <QtCore/QDebug>
 
13
 
 
14
namespace Php
 
15
{
 
16
 
 
17
class KDEVPHPPARSER_EXPORT DebugVisitor: public DefaultVisitor
 
18
{
 
19
public:
 
20
    DebugVisitor(TokenStream *str, const QString& content = QString())
 
21
            : m_str(str), m_indent(0), m_content(content) {}
 
22
    virtual void visitAdditiveExpression(AdditiveExpressionAst *node)
 
23
    {
 
24
        if (!m_indent) printToken(node, "additiveExpression");
 
25
        if (node->expression) printToken(node->expression, "multiplicativeExpression", "expression");
 
26
        if (node->additionalExpressionSequence)
 
27
        {
 
28
            const KDevPG::ListNode<AdditiveExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
 
29
            do
 
30
            {
 
31
                printToken(__it->element, "additiveExpressionRest", "additionalExpression[]");
 
32
                __it = __it->next;
 
33
            }
 
34
            while (__it != __end);
 
35
        }
 
36
        m_indent++;
 
37
        DefaultVisitor::visitAdditiveExpression(node);
 
38
        m_indent--;
 
39
    }
 
40
 
 
41
    virtual void visitAdditiveExpressionRest(AdditiveExpressionRestAst *node)
 
42
    {
 
43
        if (!m_indent) printToken(node, "additiveExpressionRest");
 
44
        if (node->expression) printToken(node->expression, "multiplicativeExpression", "expression");
 
45
        m_indent++;
 
46
        DefaultVisitor::visitAdditiveExpressionRest(node);
 
47
        m_indent--;
 
48
    }
 
49
 
 
50
    virtual void visitArrayPairValue(ArrayPairValueAst *node)
 
51
    {
 
52
        if (!m_indent) printToken(node, "arrayPairValue");
 
53
        if (node->expr) printToken(node->expr, "expr", "expr");
 
54
        if (node->exprValue) printToken(node->exprValue, "expr", "exprValue");
 
55
        if (node->varValue) printToken(node->varValue, "variable", "varValue");
 
56
        if (node->variable) printToken(node->variable, "variable", "variable");
 
57
        m_indent++;
 
58
        DefaultVisitor::visitArrayPairValue(node);
 
59
        m_indent--;
 
60
    }
 
61
 
 
62
    virtual void visitAssignmentExpression(AssignmentExpressionAst *node)
 
63
    {
 
64
        if (!m_indent) printToken(node, "assignmentExpression");
 
65
        if (node->expression) printToken(node->expression, "conditionalExpression", "expression");
 
66
        if (node->assignmentExpressionEqual) printToken(node->assignmentExpressionEqual, "assignmentExpressionEqual", "assignmentExpressionEqual");
 
67
        if (node->assignmentExpression) printToken(node->assignmentExpression, "assignmentExpression", "assignmentExpression");
 
68
        m_indent++;
 
69
        DefaultVisitor::visitAssignmentExpression(node);
 
70
        m_indent--;
 
71
    }
 
72
 
 
73
    virtual void visitAssignmentExpressionCheckIfVariable(AssignmentExpressionCheckIfVariableAst *node)
 
74
    {
 
75
        if (!m_indent) printToken(node, "assignmentExpressionCheckIfVariable");
 
76
        m_indent++;
 
77
        DefaultVisitor::visitAssignmentExpressionCheckIfVariable(node);
 
78
        m_indent--;
 
79
    }
 
80
 
 
81
    virtual void visitAssignmentExpressionEqual(AssignmentExpressionEqualAst *node)
 
82
    {
 
83
        if (!m_indent) printToken(node, "assignmentExpressionEqual");
 
84
        if (node->assignmentExpression) printToken(node->assignmentExpression, "assignmentExpression", "assignmentExpression");
 
85
        m_indent++;
 
86
        DefaultVisitor::visitAssignmentExpressionEqual(node);
 
87
        m_indent--;
 
88
    }
 
89
 
 
90
    virtual void visitAssignmentList(AssignmentListAst *node)
 
91
    {
 
92
        if (!m_indent) printToken(node, "assignmentList");
 
93
        if (node->elementSequence)
 
94
        {
 
95
            const KDevPG::ListNode<AssignmentListElementAst*> *__it = node->elementSequence->front(), *__end = __it;
 
96
            do
 
97
            {
 
98
                printToken(__it->element, "assignmentListElement", "element[]");
 
99
                __it = __it->next;
 
100
            }
 
101
            while (__it != __end);
 
102
        }
 
103
        m_indent++;
 
104
        DefaultVisitor::visitAssignmentList(node);
 
105
        m_indent--;
 
106
    }
 
107
 
 
108
    virtual void visitAssignmentListElement(AssignmentListElementAst *node)
 
109
    {
 
110
        if (!m_indent) printToken(node, "assignmentListElement");
 
111
        if (node->variable) printToken(node->variable, "variable", "variable");
 
112
        if (node->assignmentList) printToken(node->assignmentList, "assignmentList", "assignmentList");
 
113
        m_indent++;
 
114
        DefaultVisitor::visitAssignmentListElement(node);
 
115
        m_indent--;
 
116
    }
 
117
 
 
118
    virtual void visitBaseVariable(BaseVariableAst *node)
 
119
    {
 
120
        if (!m_indent) printToken(node, "baseVariable");
 
121
        if (node->var) printToken(node->var, "compoundVariableWithSimpleIndirectReference", "var");
 
122
        if (node->offsetItemsSequence)
 
123
        {
 
124
            const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
 
125
            do
 
126
            {
 
127
                printToken(__it->element, "dimListItem", "offsetItems[]");
 
128
                __it = __it->next;
 
129
            }
 
130
            while (__it != __end);
 
131
        }
 
132
        if (node->staticMember) printToken(node->staticMember, "staticMember", "staticMember");
 
133
        m_indent++;
 
134
        DefaultVisitor::visitBaseVariable(node);
 
135
        m_indent--;
 
136
    }
 
137
 
 
138
    virtual void visitBaseVariableWithFunctionCalls(BaseVariableWithFunctionCallsAst *node)
 
139
    {
 
140
        if (!m_indent) printToken(node, "baseVariableWithFunctionCalls");
 
141
        if (node->functionCall) printToken(node->functionCall, "functionCall", "functionCall");
 
142
        if (node->baseVariable) printToken(node->baseVariable, "baseVariable", "baseVariable");
 
143
        m_indent++;
 
144
        DefaultVisitor::visitBaseVariableWithFunctionCalls(node);
 
145
        m_indent--;
 
146
    }
 
147
 
 
148
    virtual void visitBitAndExpression(BitAndExpressionAst *node)
 
149
    {
 
150
        if (!m_indent) printToken(node, "bitAndExpression");
 
151
        if (node->expressionSequence)
 
152
        {
 
153
            const KDevPG::ListNode<EqualityExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
 
154
            do
 
155
            {
 
156
                printToken(__it->element, "equalityExpression", "expression[]");
 
157
                __it = __it->next;
 
158
            }
 
159
            while (__it != __end);
 
160
        }
 
161
        m_indent++;
 
162
        DefaultVisitor::visitBitAndExpression(node);
 
163
        m_indent--;
 
164
    }
 
165
 
 
166
    virtual void visitBitOrExpression(BitOrExpressionAst *node)
 
167
    {
 
168
        if (!m_indent) printToken(node, "bitOrExpression");
 
169
        if (node->expressionSequence)
 
170
        {
 
171
            const KDevPG::ListNode<BitXorExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
 
172
            do
 
173
            {
 
174
                printToken(__it->element, "bitXorExpression", "expression[]");
 
175
                __it = __it->next;
 
176
            }
 
177
            while (__it != __end);
 
178
        }
 
179
        m_indent++;
 
180
        DefaultVisitor::visitBitOrExpression(node);
 
181
        m_indent--;
 
182
    }
 
183
 
 
184
    virtual void visitBitXorExpression(BitXorExpressionAst *node)
 
185
    {
 
186
        if (!m_indent) printToken(node, "bitXorExpression");
 
187
        if (node->expressionSequence)
 
188
        {
 
189
            const KDevPG::ListNode<BitAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
 
190
            do
 
191
            {
 
192
                printToken(__it->element, "bitAndExpression", "expression[]");
 
193
                __it = __it->next;
 
194
            }
 
195
            while (__it != __end);
 
196
        }
 
197
        m_indent++;
 
198
        DefaultVisitor::visitBitXorExpression(node);
 
199
        m_indent--;
 
200
    }
 
201
 
 
202
    virtual void visitBooleanAndExpression(BooleanAndExpressionAst *node)
 
203
    {
 
204
        if (!m_indent) printToken(node, "booleanAndExpression");
 
205
        if (node->expressionSequence)
 
206
        {
 
207
            const KDevPG::ListNode<BitOrExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
 
208
            do
 
209
            {
 
210
                printToken(__it->element, "bitOrExpression", "expression[]");
 
211
                __it = __it->next;
 
212
            }
 
213
            while (__it != __end);
 
214
        }
 
215
        m_indent++;
 
216
        DefaultVisitor::visitBooleanAndExpression(node);
 
217
        m_indent--;
 
218
    }
 
219
 
 
220
    virtual void visitBooleanOrExpression(BooleanOrExpressionAst *node)
 
221
    {
 
222
        if (!m_indent) printToken(node, "booleanOrExpression");
 
223
        if (node->expressionSequence)
 
224
        {
 
225
            const KDevPG::ListNode<BooleanAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
 
226
            do
 
227
            {
 
228
                printToken(__it->element, "booleanAndExpression", "expression[]");
 
229
                __it = __it->next;
 
230
            }
 
231
            while (__it != __end);
 
232
        }
 
233
        m_indent++;
 
234
        DefaultVisitor::visitBooleanOrExpression(node);
 
235
        m_indent--;
 
236
    }
 
237
 
 
238
    virtual void visitCaseList(CaseListAst *node)
 
239
    {
 
240
        if (!m_indent) printToken(node, "caseList");
 
241
        if (node->caseItemsSequence)
 
242
        {
 
243
            const KDevPG::ListNode<Case_itemAst*> *__it = node->caseItemsSequence->front(), *__end = __it;
 
244
            do
 
245
            {
 
246
                printToken(__it->element, "case_item", "caseItems[]");
 
247
                __it = __it->next;
 
248
            }
 
249
            while (__it != __end);
 
250
        }
 
251
        m_indent++;
 
252
        DefaultVisitor::visitCaseList(node);
 
253
        m_indent--;
 
254
    }
 
255
 
 
256
    virtual void visitCase_item(Case_itemAst *node)
 
257
    {
 
258
        if (!m_indent) printToken(node, "case_item");
 
259
        if (node->expr) printToken(node->expr, "expr", "expr");
 
260
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
261
        m_indent++;
 
262
        DefaultVisitor::visitCase_item(node);
 
263
        m_indent--;
 
264
    }
 
265
 
 
266
    virtual void visitCatchItem(CatchItemAst *node)
 
267
    {
 
268
        if (!m_indent) printToken(node, "catchItem");
 
269
        if (node->catchClass) printToken(node->catchClass, "identifier", "catchClass");
 
270
        if (node->var) printToken(node->var, "variableIdentifier", "var");
 
271
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
272
        m_indent++;
 
273
        DefaultVisitor::visitCatchItem(node);
 
274
        m_indent--;
 
275
    }
 
276
 
 
277
    virtual void visitClassBody(ClassBodyAst *node)
 
278
    {
 
279
        if (!m_indent) printToken(node, "classBody");
 
280
        if (node->classStatementsSequence)
 
281
        {
 
282
            const KDevPG::ListNode<ClassStatementAst*> *__it = node->classStatementsSequence->front(), *__end = __it;
 
283
            do
 
284
            {
 
285
                printToken(__it->element, "classStatement", "classStatements[]");
 
286
                __it = __it->next;
 
287
            }
 
288
            while (__it != __end);
 
289
        }
 
290
        m_indent++;
 
291
        DefaultVisitor::visitClassBody(node);
 
292
        m_indent--;
 
293
    }
 
294
 
 
295
    virtual void visitClassConstantDeclaration(ClassConstantDeclarationAst *node)
 
296
    {
 
297
        if (!m_indent) printToken(node, "classConstantDeclaration");
 
298
        if (node->identifier) printToken(node->identifier, "identifier", "identifier");
 
299
        if (node->scalar) printToken(node->scalar, "staticScalar", "scalar");
 
300
        m_indent++;
 
301
        DefaultVisitor::visitClassConstantDeclaration(node);
 
302
        m_indent--;
 
303
    }
 
304
 
 
305
    virtual void visitClassDeclarationStatement(ClassDeclarationStatementAst *node)
 
306
    {
 
307
        if (!m_indent) printToken(node, "classDeclarationStatement");
 
308
        if (node->modifier) printToken(node->modifier, "optionalClassModifier", "modifier");
 
309
        if (node->className) printToken(node->className, "identifier", "className");
 
310
        if (node->extends) printToken(node->extends, "classExtends", "extends");
 
311
        if (node->implements) printToken(node->implements, "classImplements", "implements");
 
312
        if (node->body) printToken(node->body, "classBody", "body");
 
313
        m_indent++;
 
314
        DefaultVisitor::visitClassDeclarationStatement(node);
 
315
        m_indent--;
 
316
    }
 
317
 
 
318
    virtual void visitClassExtends(ClassExtendsAst *node)
 
319
    {
 
320
        if (!m_indent) printToken(node, "classExtends");
 
321
        if (node->identifier) printToken(node->identifier, "identifier", "identifier");
 
322
        m_indent++;
 
323
        DefaultVisitor::visitClassExtends(node);
 
324
        m_indent--;
 
325
    }
 
326
 
 
327
    virtual void visitClassImplements(ClassImplementsAst *node)
 
328
    {
 
329
        if (!m_indent) printToken(node, "classImplements");
 
330
        if (node->implementsSequence)
 
331
        {
 
332
            const KDevPG::ListNode<IdentifierAst*> *__it = node->implementsSequence->front(), *__end = __it;
 
333
            do
 
334
            {
 
335
                printToken(__it->element, "identifier", "implements[]");
 
336
                __it = __it->next;
 
337
            }
 
338
            while (__it != __end);
 
339
        }
 
340
        m_indent++;
 
341
        DefaultVisitor::visitClassImplements(node);
 
342
        m_indent--;
 
343
    }
 
344
 
 
345
    virtual void visitClassNameReference(ClassNameReferenceAst *node)
 
346
    {
 
347
        if (!m_indent) printToken(node, "classNameReference");
 
348
        if (node->identifier) printToken(node->identifier, "identifier", "identifier");
 
349
        if (node->dynamicClassNameReference) printToken(node->dynamicClassNameReference, "dynamicClassNameReference", "dynamicClassNameReference");
 
350
        m_indent++;
 
351
        DefaultVisitor::visitClassNameReference(node);
 
352
        m_indent--;
 
353
    }
 
354
 
 
355
    virtual void visitClassStatement(ClassStatementAst *node)
 
356
    {
 
357
        if (!m_indent) printToken(node, "classStatement");
 
358
        if (node->consts) printToken(node->consts, "classConstantDeclaration", "consts");
 
359
        if (node->variable) printToken(node->variable, "classVariableDeclaration", "variable");
 
360
        if (node->modifiers) printToken(node->modifiers, "optionalModifiers", "modifiers");
 
361
        if (node->methodName) printToken(node->methodName, "identifier", "methodName");
 
362
        if (node->parameters) printToken(node->parameters, "parameterList", "parameters");
 
363
        if (node->methodBody) printToken(node->methodBody, "methodBody", "methodBody");
 
364
        m_indent++;
 
365
        DefaultVisitor::visitClassStatement(node);
 
366
        m_indent--;
 
367
    }
 
368
 
 
369
    virtual void visitClassVariable(ClassVariableAst *node)
 
370
    {
 
371
        if (!m_indent) printToken(node, "classVariable");
 
372
        if (node->variable) printToken(node->variable, "variableIdentifier", "variable");
 
373
        if (node->value) printToken(node->value, "staticScalar", "value");
 
374
        m_indent++;
 
375
        DefaultVisitor::visitClassVariable(node);
 
376
        m_indent--;
 
377
    }
 
378
 
 
379
    virtual void visitClassVariableDeclaration(ClassVariableDeclarationAst *node)
 
380
    {
 
381
        if (!m_indent) printToken(node, "classVariableDeclaration");
 
382
        if (node->varsSequence)
 
383
        {
 
384
            const KDevPG::ListNode<ClassVariableAst*> *__it = node->varsSequence->front(), *__end = __it;
 
385
            do
 
386
            {
 
387
                printToken(__it->element, "classVariable", "vars[]");
 
388
                __it = __it->next;
 
389
            }
 
390
            while (__it != __end);
 
391
        }
 
392
        m_indent++;
 
393
        DefaultVisitor::visitClassVariableDeclaration(node);
 
394
        m_indent--;
 
395
    }
 
396
 
 
397
    virtual void visitCommonScalar(CommonScalarAst *node)
 
398
    {
 
399
        if (!m_indent) printToken(node, "commonScalar");
 
400
        m_indent++;
 
401
        DefaultVisitor::visitCommonScalar(node);
 
402
        m_indent--;
 
403
    }
 
404
 
 
405
    virtual void visitCompoundVariable(CompoundVariableAst *node)
 
406
    {
 
407
        if (!m_indent) printToken(node, "compoundVariable");
 
408
        if (node->variable) printToken(node->variable, "variableIdentifier", "variable");
 
409
        if (node->expr) printToken(node->expr, "expr", "expr");
 
410
        m_indent++;
 
411
        DefaultVisitor::visitCompoundVariable(node);
 
412
        m_indent--;
 
413
    }
 
414
 
 
415
    virtual void visitCompoundVariableWithSimpleIndirectReference(CompoundVariableWithSimpleIndirectReferenceAst *node)
 
416
    {
 
417
        if (!m_indent) printToken(node, "compoundVariableWithSimpleIndirectReference");
 
418
        if (node->indirectVariable) printToken(node->indirectVariable, "variableIdentifier", "indirectVariable");
 
419
        if (node->expr) printToken(node->expr, "expr", "expr");
 
420
        if (node->variable) printToken(node->variable, "variableIdentifier", "variable");
 
421
        m_indent++;
 
422
        DefaultVisitor::visitCompoundVariableWithSimpleIndirectReference(node);
 
423
        m_indent--;
 
424
    }
 
425
 
 
426
    virtual void visitConditionalExpression(ConditionalExpressionAst *node)
 
427
    {
 
428
        if (!m_indent) printToken(node, "conditionalExpression");
 
429
        if (node->expression) printToken(node->expression, "booleanOrExpression", "expression");
 
430
        if (node->ifExpression) printToken(node->ifExpression, "expr", "ifExpression");
 
431
        if (node->elseExpression) printToken(node->elseExpression, "conditionalExpression", "elseExpression");
 
432
        m_indent++;
 
433
        DefaultVisitor::visitConditionalExpression(node);
 
434
        m_indent--;
 
435
    }
 
436
 
 
437
    virtual void visitConstantOrClassConst(ConstantOrClassConstAst *node)
 
438
    {
 
439
        if (!m_indent) printToken(node, "constantOrClassConst");
 
440
        if (node->className) printToken(node->className, "identifier", "className");
 
441
        if (node->constant) printToken(node->constant, "identifier", "constant");
 
442
        m_indent++;
 
443
        DefaultVisitor::visitConstantOrClassConst(node);
 
444
        m_indent--;
 
445
    }
 
446
 
 
447
    virtual void visitCtorArguments(CtorArgumentsAst *node)
 
448
    {
 
449
        if (!m_indent) printToken(node, "ctorArguments");
 
450
        if (node->parameterList) printToken(node->parameterList, "functionCallParameterList", "parameterList");
 
451
        m_indent++;
 
452
        DefaultVisitor::visitCtorArguments(node);
 
453
        m_indent--;
 
454
    }
 
455
 
 
456
    virtual void visitDeclareItem(DeclareItemAst *node)
 
457
    {
 
458
        if (!m_indent) printToken(node, "declareItem");
 
459
        if (node->scalar) printToken(node->scalar, "staticScalar", "scalar");
 
460
        m_indent++;
 
461
        DefaultVisitor::visitDeclareItem(node);
 
462
        m_indent--;
 
463
    }
 
464
 
 
465
    virtual void visitDeclareStatement(DeclareStatementAst *node)
 
466
    {
 
467
        if (!m_indent) printToken(node, "declareStatement");
 
468
        if (node->statement) printToken(node->statement, "statement", "statement");
 
469
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
470
        m_indent++;
 
471
        DefaultVisitor::visitDeclareStatement(node);
 
472
        m_indent--;
 
473
    }
 
474
 
 
475
    virtual void visitDimListItem(DimListItemAst *node)
 
476
    {
 
477
        if (!m_indent) printToken(node, "dimListItem");
 
478
        if (node->dimOffset) printToken(node->dimOffset, "dimOffset", "dimOffset");
 
479
        if (node->expr) printToken(node->expr, "expr", "expr");
 
480
        m_indent++;
 
481
        DefaultVisitor::visitDimListItem(node);
 
482
        m_indent--;
 
483
    }
 
484
 
 
485
    virtual void visitDimOffset(DimOffsetAst *node)
 
486
    {
 
487
        if (!m_indent) printToken(node, "dimOffset");
 
488
        if (node->expr) printToken(node->expr, "expr", "expr");
 
489
        m_indent++;
 
490
        DefaultVisitor::visitDimOffset(node);
 
491
        m_indent--;
 
492
    }
 
493
 
 
494
    virtual void visitDynamicClassNameReference(DynamicClassNameReferenceAst *node)
 
495
    {
 
496
        if (!m_indent) printToken(node, "dynamicClassNameReference");
 
497
        if (node->baseVariable) printToken(node->baseVariable, "baseVariable", "baseVariable");
 
498
        if (node->objectProperty) printToken(node->objectProperty, "objectProperty", "objectProperty");
 
499
        if (node->properties) printToken(node->properties, "dynamicClassNameVariableProperties", "properties");
 
500
        m_indent++;
 
501
        DefaultVisitor::visitDynamicClassNameReference(node);
 
502
        m_indent--;
 
503
    }
 
504
 
 
505
    virtual void visitDynamicClassNameVariableProperties(DynamicClassNameVariablePropertiesAst *node)
 
506
    {
 
507
        if (!m_indent) printToken(node, "dynamicClassNameVariableProperties");
 
508
        if (node->propertiesSequence)
 
509
        {
 
510
            const KDevPG::ListNode<DynamicClassNameVariablePropertyAst*> *__it = node->propertiesSequence->front(), *__end = __it;
 
511
            do
 
512
            {
 
513
                printToken(__it->element, "dynamicClassNameVariableProperty", "properties[]");
 
514
                __it = __it->next;
 
515
            }
 
516
            while (__it != __end);
 
517
        }
 
518
        m_indent++;
 
519
        DefaultVisitor::visitDynamicClassNameVariableProperties(node);
 
520
        m_indent--;
 
521
    }
 
522
 
 
523
    virtual void visitDynamicClassNameVariableProperty(DynamicClassNameVariablePropertyAst *node)
 
524
    {
 
525
        if (!m_indent) printToken(node, "dynamicClassNameVariableProperty");
 
526
        if (node->property) printToken(node->property, "objectProperty", "property");
 
527
        m_indent++;
 
528
        DefaultVisitor::visitDynamicClassNameVariableProperty(node);
 
529
        m_indent--;
 
530
    }
 
531
 
 
532
    virtual void visitElseSingle(ElseSingleAst *node)
 
533
    {
 
534
        if (!m_indent) printToken(node, "elseSingle");
 
535
        if (node->statement) printToken(node->statement, "statement", "statement");
 
536
        m_indent++;
 
537
        DefaultVisitor::visitElseSingle(node);
 
538
        m_indent--;
 
539
    }
 
540
 
 
541
    virtual void visitElseifList(ElseifListAst *node)
 
542
    {
 
543
        if (!m_indent) printToken(node, "elseifList");
 
544
        if (node->elseifListItemSequence)
 
545
        {
 
546
            const KDevPG::ListNode<ElseifListItemAst*> *__it = node->elseifListItemSequence->front(), *__end = __it;
 
547
            do
 
548
            {
 
549
                printToken(__it->element, "elseifListItem", "elseifListItem[]");
 
550
                __it = __it->next;
 
551
            }
 
552
            while (__it != __end);
 
553
        }
 
554
        m_indent++;
 
555
        DefaultVisitor::visitElseifList(node);
 
556
        m_indent--;
 
557
    }
 
558
 
 
559
    virtual void visitElseifListItem(ElseifListItemAst *node)
 
560
    {
 
561
        if (!m_indent) printToken(node, "elseifListItem");
 
562
        if (node->expr) printToken(node->expr, "expr", "expr");
 
563
        if (node->statement) printToken(node->statement, "statement", "statement");
 
564
        m_indent++;
 
565
        DefaultVisitor::visitElseifListItem(node);
 
566
        m_indent--;
 
567
    }
 
568
 
 
569
    virtual void visitEncaps(EncapsAst *node)
 
570
    {
 
571
        if (!m_indent) printToken(node, "encaps");
 
572
        if (node->var) printToken(node->var, "encapsVar", "var");
 
573
        m_indent++;
 
574
        DefaultVisitor::visitEncaps(node);
 
575
        m_indent--;
 
576
    }
 
577
 
 
578
    virtual void visitEncapsList(EncapsListAst *node)
 
579
    {
 
580
        if (!m_indent) printToken(node, "encapsList");
 
581
        if (node->encapsSequence)
 
582
        {
 
583
            const KDevPG::ListNode<EncapsAst*> *__it = node->encapsSequence->front(), *__end = __it;
 
584
            do
 
585
            {
 
586
                printToken(__it->element, "encaps", "encaps[]");
 
587
                __it = __it->next;
 
588
            }
 
589
            while (__it != __end);
 
590
        }
 
591
        m_indent++;
 
592
        DefaultVisitor::visitEncapsList(node);
 
593
        m_indent--;
 
594
    }
 
595
 
 
596
    virtual void visitEncapsVar(EncapsVarAst *node)
 
597
    {
 
598
        if (!m_indent) printToken(node, "encapsVar");
 
599
        if (node->expr) printToken(node->expr, "expr", "expr");
 
600
        if (node->variable) printToken(node->variable, "variableIdentifier", "variable");
 
601
        if (node->propertyIdentifier) printToken(node->propertyIdentifier, "identifier", "propertyIdentifier");
 
602
        if (node->offset) printToken(node->offset, "encapsVarOffset", "offset");
 
603
        m_indent++;
 
604
        DefaultVisitor::visitEncapsVar(node);
 
605
        m_indent--;
 
606
    }
 
607
 
 
608
    virtual void visitEncapsVarOffset(EncapsVarOffsetAst *node)
 
609
    {
 
610
        if (!m_indent) printToken(node, "encapsVarOffset");
 
611
        m_indent++;
 
612
        DefaultVisitor::visitEncapsVarOffset(node);
 
613
        m_indent--;
 
614
    }
 
615
 
 
616
    virtual void visitEqualityExpression(EqualityExpressionAst *node)
 
617
    {
 
618
        if (!m_indent) printToken(node, "equalityExpression");
 
619
        if (node->expression) printToken(node->expression, "relationalExpression", "expression");
 
620
        if (node->additionalExpressionSequence)
 
621
        {
 
622
            const KDevPG::ListNode<EqualityExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
 
623
            do
 
624
            {
 
625
                printToken(__it->element, "equalityExpressionRest", "additionalExpression[]");
 
626
                __it = __it->next;
 
627
            }
 
628
            while (__it != __end);
 
629
        }
 
630
        m_indent++;
 
631
        DefaultVisitor::visitEqualityExpression(node);
 
632
        m_indent--;
 
633
    }
 
634
 
 
635
    virtual void visitEqualityExpressionRest(EqualityExpressionRestAst *node)
 
636
    {
 
637
        if (!m_indent) printToken(node, "equalityExpressionRest");
 
638
        if (node->expression) printToken(node->expression, "relationalExpression", "expression");
 
639
        m_indent++;
 
640
        DefaultVisitor::visitEqualityExpressionRest(node);
 
641
        m_indent--;
 
642
    }
 
643
 
 
644
    virtual void visitExpr(ExprAst *node)
 
645
    {
 
646
        if (!m_indent) printToken(node, "expr");
 
647
        if (node->expression) printToken(node->expression, "logicalOrExpression", "expression");
 
648
        m_indent++;
 
649
        DefaultVisitor::visitExpr(node);
 
650
        m_indent--;
 
651
    }
 
652
 
 
653
    virtual void visitForExpr(ForExprAst *node)
 
654
    {
 
655
        if (!m_indent) printToken(node, "forExpr");
 
656
        if (node->exprsSequence)
 
657
        {
 
658
            const KDevPG::ListNode<ExprAst*> *__it = node->exprsSequence->front(), *__end = __it;
 
659
            do
 
660
            {
 
661
                printToken(__it->element, "expr", "exprs[]");
 
662
                __it = __it->next;
 
663
            }
 
664
            while (__it != __end);
 
665
        }
 
666
        m_indent++;
 
667
        DefaultVisitor::visitForExpr(node);
 
668
        m_indent--;
 
669
    }
 
670
 
 
671
    virtual void visitForStatement(ForStatementAst *node)
 
672
    {
 
673
        if (!m_indent) printToken(node, "forStatement");
 
674
        if (node->statement) printToken(node->statement, "statement", "statement");
 
675
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
676
        m_indent++;
 
677
        DefaultVisitor::visitForStatement(node);
 
678
        m_indent--;
 
679
    }
 
680
 
 
681
    virtual void visitForeachStatement(ForeachStatementAst *node)
 
682
    {
 
683
        if (!m_indent) printToken(node, "foreachStatement");
 
684
        if (node->statement) printToken(node->statement, "statement", "statement");
 
685
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
686
        m_indent++;
 
687
        DefaultVisitor::visitForeachStatement(node);
 
688
        m_indent--;
 
689
    }
 
690
 
 
691
    virtual void visitForeachVariable(ForeachVariableAst *node)
 
692
    {
 
693
        if (!m_indent) printToken(node, "foreachVariable");
 
694
        if (node->variable) printToken(node->variable, "variableIdentifier", "variable");
 
695
        m_indent++;
 
696
        DefaultVisitor::visitForeachVariable(node);
 
697
        m_indent--;
 
698
    }
 
699
 
 
700
    virtual void visitFunctionCall(FunctionCallAst *node)
 
701
    {
 
702
        if (!m_indent) printToken(node, "functionCall");
 
703
        if (node->stringFunctionNameOrClass) printToken(node->stringFunctionNameOrClass, "identifier", "stringFunctionNameOrClass");
 
704
        if (node->stringParameterList) printToken(node->stringParameterList, "functionCallParameterList", "stringParameterList");
 
705
        if (node->stringFunctionName) printToken(node->stringFunctionName, "identifier", "stringFunctionName");
 
706
        if (node->varFunctionName) printToken(node->varFunctionName, "variableWithoutObjects", "varFunctionName");
 
707
        if (node->varParameterList) printToken(node->varParameterList, "functionCallParameterList", "varParameterList");
 
708
        m_indent++;
 
709
        DefaultVisitor::visitFunctionCall(node);
 
710
        m_indent--;
 
711
    }
 
712
 
 
713
    virtual void visitFunctionCallParameterList(FunctionCallParameterListAst *node)
 
714
    {
 
715
        if (!m_indent) printToken(node, "functionCallParameterList");
 
716
        if (node->parametersSequence)
 
717
        {
 
718
            const KDevPG::ListNode<FunctionCallParameterListElementAst*> *__it = node->parametersSequence->front(), *__end = __it;
 
719
            do
 
720
            {
 
721
                printToken(__it->element, "functionCallParameterListElement", "parameters[]");
 
722
                __it = __it->next;
 
723
            }
 
724
            while (__it != __end);
 
725
        }
 
726
        m_indent++;
 
727
        DefaultVisitor::visitFunctionCallParameterList(node);
 
728
        m_indent--;
 
729
    }
 
730
 
 
731
    virtual void visitFunctionCallParameterListElement(FunctionCallParameterListElementAst *node)
 
732
    {
 
733
        if (!m_indent) printToken(node, "functionCallParameterListElement");
 
734
        if (node->variable) printToken(node->variable, "variable", "variable");
 
735
        if (node->expr) printToken(node->expr, "expr", "expr");
 
736
        m_indent++;
 
737
        DefaultVisitor::visitFunctionCallParameterListElement(node);
 
738
        m_indent--;
 
739
    }
 
740
 
 
741
    virtual void visitFunctionDeclarationStatement(FunctionDeclarationStatementAst *node)
 
742
    {
 
743
        if (!m_indent) printToken(node, "functionDeclarationStatement");
 
744
        if (node->functionName) printToken(node->functionName, "identifier", "functionName");
 
745
        if (node->parameters) printToken(node->parameters, "parameterList", "parameters");
 
746
        if (node->functionBody) printToken(node->functionBody, "innerStatementList", "functionBody");
 
747
        m_indent++;
 
748
        DefaultVisitor::visitFunctionDeclarationStatement(node);
 
749
        m_indent--;
 
750
    }
 
751
 
 
752
    virtual void visitGlobalVar(GlobalVarAst *node)
 
753
    {
 
754
        if (!m_indent) printToken(node, "globalVar");
 
755
        if (node->var) printToken(node->var, "variableIdentifier", "var");
 
756
        if (node->dollarVar) printToken(node->dollarVar, "variable", "dollarVar");
 
757
        if (node->expr) printToken(node->expr, "expr", "expr");
 
758
        m_indent++;
 
759
        DefaultVisitor::visitGlobalVar(node);
 
760
        m_indent--;
 
761
    }
 
762
 
 
763
    virtual void visitIdentifier(IdentifierAst *node)
 
764
    {
 
765
        if (!m_indent) printToken(node, "identifier");
 
766
        m_indent++;
 
767
        DefaultVisitor::visitIdentifier(node);
 
768
        m_indent--;
 
769
    }
 
770
 
 
771
    virtual void visitInnerStatementList(InnerStatementListAst *node)
 
772
    {
 
773
        if (!m_indent) printToken(node, "innerStatementList");
 
774
        if (node->statementsSequence)
 
775
        {
 
776
            const KDevPG::ListNode<TopStatementAst*> *__it = node->statementsSequence->front(), *__end = __it;
 
777
            do
 
778
            {
 
779
                printToken(__it->element, "topStatement", "statements[]");
 
780
                __it = __it->next;
 
781
            }
 
782
            while (__it != __end);
 
783
        }
 
784
        m_indent++;
 
785
        DefaultVisitor::visitInnerStatementList(node);
 
786
        m_indent--;
 
787
    }
 
788
 
 
789
    virtual void visitInterfaceDeclarationStatement(InterfaceDeclarationStatementAst *node)
 
790
    {
 
791
        if (!m_indent) printToken(node, "interfaceDeclarationStatement");
 
792
        if (node->interfaceName) printToken(node->interfaceName, "identifier", "interfaceName");
 
793
        if (node->extends) printToken(node->extends, "classImplements", "extends");
 
794
        if (node->body) printToken(node->body, "classBody", "body");
 
795
        m_indent++;
 
796
        DefaultVisitor::visitInterfaceDeclarationStatement(node);
 
797
        m_indent--;
 
798
    }
 
799
 
 
800
    virtual void visitLogicalAndExpression(LogicalAndExpressionAst *node)
 
801
    {
 
802
        if (!m_indent) printToken(node, "logicalAndExpression");
 
803
        if (node->expressionSequence)
 
804
        {
 
805
            const KDevPG::ListNode<PrintExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
 
806
            do
 
807
            {
 
808
                printToken(__it->element, "printExpression", "expression[]");
 
809
                __it = __it->next;
 
810
            }
 
811
            while (__it != __end);
 
812
        }
 
813
        m_indent++;
 
814
        DefaultVisitor::visitLogicalAndExpression(node);
 
815
        m_indent--;
 
816
    }
 
817
 
 
818
    virtual void visitLogicalOrExpression(LogicalOrExpressionAst *node)
 
819
    {
 
820
        if (!m_indent) printToken(node, "logicalOrExpression");
 
821
        if (node->expressionSequence)
 
822
        {
 
823
            const KDevPG::ListNode<LogicalXorExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
 
824
            do
 
825
            {
 
826
                printToken(__it->element, "logicalXorExpression", "expression[]");
 
827
                __it = __it->next;
 
828
            }
 
829
            while (__it != __end);
 
830
        }
 
831
        m_indent++;
 
832
        DefaultVisitor::visitLogicalOrExpression(node);
 
833
        m_indent--;
 
834
    }
 
835
 
 
836
    virtual void visitLogicalXorExpression(LogicalXorExpressionAst *node)
 
837
    {
 
838
        if (!m_indent) printToken(node, "logicalXorExpression");
 
839
        if (node->expressionSequence)
 
840
        {
 
841
            const KDevPG::ListNode<LogicalAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
 
842
            do
 
843
            {
 
844
                printToken(__it->element, "logicalAndExpression", "expression[]");
 
845
                __it = __it->next;
 
846
            }
 
847
            while (__it != __end);
 
848
        }
 
849
        m_indent++;
 
850
        DefaultVisitor::visitLogicalXorExpression(node);
 
851
        m_indent--;
 
852
    }
 
853
 
 
854
    virtual void visitMethodBody(MethodBodyAst *node)
 
855
    {
 
856
        if (!m_indent) printToken(node, "methodBody");
 
857
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
858
        m_indent++;
 
859
        DefaultVisitor::visitMethodBody(node);
 
860
        m_indent--;
 
861
    }
 
862
 
 
863
    virtual void visitMultiplicativeExpression(MultiplicativeExpressionAst *node)
 
864
    {
 
865
        if (!m_indent) printToken(node, "multiplicativeExpression");
 
866
        if (node->expression) printToken(node->expression, "unaryExpression", "expression");
 
867
        if (node->additionalExpressionSequence)
 
868
        {
 
869
            const KDevPG::ListNode<MultiplicativeExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
 
870
            do
 
871
            {
 
872
                printToken(__it->element, "multiplicativeExpressionRest", "additionalExpression[]");
 
873
                __it = __it->next;
 
874
            }
 
875
            while (__it != __end);
 
876
        }
 
877
        m_indent++;
 
878
        DefaultVisitor::visitMultiplicativeExpression(node);
 
879
        m_indent--;
 
880
    }
 
881
 
 
882
    virtual void visitMultiplicativeExpressionRest(MultiplicativeExpressionRestAst *node)
 
883
    {
 
884
        if (!m_indent) printToken(node, "multiplicativeExpressionRest");
 
885
        if (node->expression) printToken(node->expression, "unaryExpression", "expression");
 
886
        m_indent++;
 
887
        DefaultVisitor::visitMultiplicativeExpressionRest(node);
 
888
        m_indent--;
 
889
    }
 
890
 
 
891
    virtual void visitNewElseSingle(NewElseSingleAst *node)
 
892
    {
 
893
        if (!m_indent) printToken(node, "newElseSingle");
 
894
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
895
        m_indent++;
 
896
        DefaultVisitor::visitNewElseSingle(node);
 
897
        m_indent--;
 
898
    }
 
899
 
 
900
    virtual void visitNewElseifList(NewElseifListAst *node)
 
901
    {
 
902
        if (!m_indent) printToken(node, "newElseifList");
 
903
        if (node->newElseifListItemSequence)
 
904
        {
 
905
            const KDevPG::ListNode<NewelseifListItemAst*> *__it = node->newElseifListItemSequence->front(), *__end = __it;
 
906
            do
 
907
            {
 
908
                printToken(__it->element, "newelseifListItem", "newElseifListItem[]");
 
909
                __it = __it->next;
 
910
            }
 
911
            while (__it != __end);
 
912
        }
 
913
        m_indent++;
 
914
        DefaultVisitor::visitNewElseifList(node);
 
915
        m_indent--;
 
916
    }
 
917
 
 
918
    virtual void visitNewelseifListItem(NewelseifListItemAst *node)
 
919
    {
 
920
        if (!m_indent) printToken(node, "newelseifListItem");
 
921
        if (node->expr) printToken(node->expr, "expr", "expr");
 
922
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
923
        m_indent++;
 
924
        DefaultVisitor::visitNewelseifListItem(node);
 
925
        m_indent--;
 
926
    }
 
927
 
 
928
    virtual void visitObjectDimList(ObjectDimListAst *node)
 
929
    {
 
930
        if (!m_indent) printToken(node, "objectDimList");
 
931
        if (node->variableName) printToken(node->variableName, "variableName", "variableName");
 
932
        if (node->offsetItemsSequence)
 
933
        {
 
934
            const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
 
935
            do
 
936
            {
 
937
                printToken(__it->element, "dimListItem", "offsetItems[]");
 
938
                __it = __it->next;
 
939
            }
 
940
            while (__it != __end);
 
941
        }
 
942
        m_indent++;
 
943
        DefaultVisitor::visitObjectDimList(node);
 
944
        m_indent--;
 
945
    }
 
946
 
 
947
    virtual void visitObjectProperty(ObjectPropertyAst *node)
 
948
    {
 
949
        if (!m_indent) printToken(node, "objectProperty");
 
950
        if (node->objectDimList) printToken(node->objectDimList, "objectDimList", "objectDimList");
 
951
        if (node->variableWithoutObjects) printToken(node->variableWithoutObjects, "variableWithoutObjects", "variableWithoutObjects");
 
952
        m_indent++;
 
953
        DefaultVisitor::visitObjectProperty(node);
 
954
        m_indent--;
 
955
    }
 
956
 
 
957
    virtual void visitOptionalClassModifier(OptionalClassModifierAst *node)
 
958
    {
 
959
        if (!m_indent) printToken(node, "optionalClassModifier");
 
960
        m_indent++;
 
961
        DefaultVisitor::visitOptionalClassModifier(node);
 
962
        m_indent--;
 
963
    }
 
964
 
 
965
    virtual void visitOptionalModifiers(OptionalModifiersAst *node)
 
966
    {
 
967
        if (!m_indent) printToken(node, "optionalModifiers");
 
968
        m_indent++;
 
969
        DefaultVisitor::visitOptionalModifiers(node);
 
970
        m_indent--;
 
971
    }
 
972
 
 
973
    virtual void visitParameter(ParameterAst *node)
 
974
    {
 
975
        if (!m_indent) printToken(node, "parameter");
 
976
        if (node->parameterType) printToken(node->parameterType, "identifier", "parameterType");
 
977
        if (node->variable) printToken(node->variable, "variableIdentifier", "variable");
 
978
        if (node->defaultValue) printToken(node->defaultValue, "staticScalar", "defaultValue");
 
979
        m_indent++;
 
980
        DefaultVisitor::visitParameter(node);
 
981
        m_indent--;
 
982
    }
 
983
 
 
984
    virtual void visitParameterList(ParameterListAst *node)
 
985
    {
 
986
        if (!m_indent) printToken(node, "parameterList");
 
987
        if (node->parametersSequence)
 
988
        {
 
989
            const KDevPG::ListNode<ParameterAst*> *__it = node->parametersSequence->front(), *__end = __it;
 
990
            do
 
991
            {
 
992
                printToken(__it->element, "parameter", "parameters[]");
 
993
                __it = __it->next;
 
994
            }
 
995
            while (__it != __end);
 
996
        }
 
997
        m_indent++;
 
998
        DefaultVisitor::visitParameterList(node);
 
999
        m_indent--;
 
1000
    }
 
1001
 
 
1002
    virtual void visitPostprefixOperator(PostprefixOperatorAst *node)
 
1003
    {
 
1004
        if (!m_indent) printToken(node, "postprefixOperator");
 
1005
        m_indent++;
 
1006
        DefaultVisitor::visitPostprefixOperator(node);
 
1007
        m_indent--;
 
1008
    }
 
1009
 
 
1010
    virtual void visitPrintExpression(PrintExpressionAst *node)
 
1011
    {
 
1012
        if (!m_indent) printToken(node, "printExpression");
 
1013
        if (node->expression) printToken(node->expression, "assignmentExpression", "expression");
 
1014
        m_indent++;
 
1015
        DefaultVisitor::visitPrintExpression(node);
 
1016
        m_indent--;
 
1017
    }
 
1018
 
 
1019
    virtual void visitRelationalExpression(RelationalExpressionAst *node)
 
1020
    {
 
1021
        if (!m_indent) printToken(node, "relationalExpression");
 
1022
        if (node->expression) printToken(node->expression, "shiftExpression", "expression");
 
1023
        if (node->additionalExpressionSequence)
 
1024
        {
 
1025
            const KDevPG::ListNode<RelationalExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
 
1026
            do
 
1027
            {
 
1028
                printToken(__it->element, "relationalExpressionRest", "additionalExpression[]");
 
1029
                __it = __it->next;
 
1030
            }
 
1031
            while (__it != __end);
 
1032
        }
 
1033
        if (node->instanceofType) printToken(node->instanceofType, "classNameReference", "instanceofType");
 
1034
        m_indent++;
 
1035
        DefaultVisitor::visitRelationalExpression(node);
 
1036
        m_indent--;
 
1037
    }
 
1038
 
 
1039
    virtual void visitRelationalExpressionRest(RelationalExpressionRestAst *node)
 
1040
    {
 
1041
        if (!m_indent) printToken(node, "relationalExpressionRest");
 
1042
        if (node->expression) printToken(node->expression, "shiftExpression", "expression");
 
1043
        m_indent++;
 
1044
        DefaultVisitor::visitRelationalExpressionRest(node);
 
1045
        m_indent--;
 
1046
    }
 
1047
 
 
1048
    virtual void visitScalar(ScalarAst *node)
 
1049
    {
 
1050
        if (!m_indent) printToken(node, "scalar");
 
1051
        if (node->commonScalar) printToken(node->commonScalar, "commonScalar", "commonScalar");
 
1052
        if (node->constantOrClassConst) printToken(node->constantOrClassConst, "constantOrClassConst", "constantOrClassConst");
 
1053
        if (node->encapsList) printToken(node->encapsList, "encapsList", "encapsList");
 
1054
        m_indent++;
 
1055
        DefaultVisitor::visitScalar(node);
 
1056
        m_indent--;
 
1057
    }
 
1058
 
 
1059
    virtual void visitSemicolonOrCloseTag(SemicolonOrCloseTagAst *node)
 
1060
    {
 
1061
        if (!m_indent) printToken(node, "semicolonOrCloseTag");
 
1062
        m_indent++;
 
1063
        DefaultVisitor::visitSemicolonOrCloseTag(node);
 
1064
        m_indent--;
 
1065
    }
 
1066
 
 
1067
    virtual void visitShiftExpression(ShiftExpressionAst *node)
 
1068
    {
 
1069
        if (!m_indent) printToken(node, "shiftExpression");
 
1070
        if (node->expression) printToken(node->expression, "additiveExpression", "expression");
 
1071
        if (node->additionalExpressionSequence)
 
1072
        {
 
1073
            const KDevPG::ListNode<ShiftExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
 
1074
            do
 
1075
            {
 
1076
                printToken(__it->element, "shiftExpressionRest", "additionalExpression[]");
 
1077
                __it = __it->next;
 
1078
            }
 
1079
            while (__it != __end);
 
1080
        }
 
1081
        m_indent++;
 
1082
        DefaultVisitor::visitShiftExpression(node);
 
1083
        m_indent--;
 
1084
    }
 
1085
 
 
1086
    virtual void visitShiftExpressionRest(ShiftExpressionRestAst *node)
 
1087
    {
 
1088
        if (!m_indent) printToken(node, "shiftExpressionRest");
 
1089
        if (node->expression) printToken(node->expression, "additiveExpression", "expression");
 
1090
        m_indent++;
 
1091
        DefaultVisitor::visitShiftExpressionRest(node);
 
1092
        m_indent--;
 
1093
    }
 
1094
 
 
1095
    virtual void visitStart(StartAst *node)
 
1096
    {
 
1097
        if (!m_indent) printToken(node, "start");
 
1098
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
1099
        m_indent++;
 
1100
        DefaultVisitor::visitStart(node);
 
1101
        m_indent--;
 
1102
    }
 
1103
 
 
1104
    virtual void visitStatement(StatementAst *node)
 
1105
    {
 
1106
        if (!m_indent) printToken(node, "statement");
 
1107
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
1108
        if (node->ifExpr) printToken(node->ifExpr, "expr", "ifExpr");
 
1109
        if (node->ifStatement) printToken(node->ifStatement, "statement", "ifStatement");
 
1110
        if (node->elseifList) printToken(node->elseifList, "elseifList", "elseifList");
 
1111
        if (node->elseSingle) printToken(node->elseSingle, "elseSingle", "elseSingle");
 
1112
        if (node->whileExpr) printToken(node->whileExpr, "expr", "whileExpr");
 
1113
        if (node->whilteStatement) printToken(node->whilteStatement, "whileStatement", "whilteStatement");
 
1114
        if (node->forExpr1) printToken(node->forExpr1, "forExpr", "forExpr1");
 
1115
        if (node->forExpr2) printToken(node->forExpr2, "forExpr", "forExpr2");
 
1116
        if (node->forExpr3) printToken(node->forExpr3, "forExpr", "forExpr3");
 
1117
        if (node->forStatement) printToken(node->forStatement, "forStatement", "forStatement");
 
1118
        if (node->swtichExpr) printToken(node->swtichExpr, "expr", "swtichExpr");
 
1119
        if (node->switchCaseList) printToken(node->switchCaseList, "switchCaseList", "switchCaseList");
 
1120
        if (node->foreachVar) printToken(node->foreachVar, "variable", "foreachVar");
 
1121
        if (node->foreachVarAsVar) printToken(node->foreachVarAsVar, "foreachVariable", "foreachVarAsVar");
 
1122
        if (node->foreachExpr) printToken(node->foreachExpr, "expr", "foreachExpr");
 
1123
        if (node->foreachExprAsVar) printToken(node->foreachExprAsVar, "variableIdentifier", "foreachExprAsVar");
 
1124
        if (node->foreachVariable) printToken(node->foreachVariable, "foreachVariable", "foreachVariable");
 
1125
        if (node->foreachStatement) printToken(node->foreachStatement, "foreachStatement", "foreachStatement");
 
1126
        if (node->declareItem) printToken(node->declareItem, "declareItem", "declareItem");
 
1127
        if (node->catchesSequence)
 
1128
        {
 
1129
            const KDevPG::ListNode<CatchItemAst*> *__it = node->catchesSequence->front(), *__end = __it;
 
1130
            do
 
1131
            {
 
1132
                printToken(__it->element, "catchItem", "catches[]");
 
1133
                __it = __it->next;
 
1134
            }
 
1135
            while (__it != __end);
 
1136
        }
 
1137
        if (node->unsetVariablesSequence)
 
1138
        {
 
1139
            const KDevPG::ListNode<VariableAst*> *__it = node->unsetVariablesSequence->front(), *__end = __it;
 
1140
            do
 
1141
            {
 
1142
                printToken(__it->element, "variable", "unsetVariables[]");
 
1143
                __it = __it->next;
 
1144
            }
 
1145
            while (__it != __end);
 
1146
        }
 
1147
        if (node->expr) printToken(node->expr, "expr", "expr");
 
1148
        if (node->doStatement) printToken(node->doStatement, "statement", "doStatement");
 
1149
        if (node->whilteExpr) printToken(node->whilteExpr, "expr", "whilteExpr");
 
1150
        if (node->breakExpr) printToken(node->breakExpr, "expr", "breakExpr");
 
1151
        if (node->continueExpr) printToken(node->continueExpr, "expr", "continueExpr");
 
1152
        if (node->returnExpr) printToken(node->returnExpr, "expr", "returnExpr");
 
1153
        if (node->globalVarsSequence)
 
1154
        {
 
1155
            const KDevPG::ListNode<GlobalVarAst*> *__it = node->globalVarsSequence->front(), *__end = __it;
 
1156
            do
 
1157
            {
 
1158
                printToken(__it->element, "globalVar", "globalVars[]");
 
1159
                __it = __it->next;
 
1160
            }
 
1161
            while (__it != __end);
 
1162
        }
 
1163
        if (node->staticVarsSequence)
 
1164
        {
 
1165
            const KDevPG::ListNode<StaticVarAst*> *__it = node->staticVarsSequence->front(), *__end = __it;
 
1166
            do
 
1167
            {
 
1168
                printToken(__it->element, "staticVar", "staticVars[]");
 
1169
                __it = __it->next;
 
1170
            }
 
1171
            while (__it != __end);
 
1172
        }
 
1173
        if (node->echoExprsSequence)
 
1174
        {
 
1175
            const KDevPG::ListNode<ExprAst*> *__it = node->echoExprsSequence->front(), *__end = __it;
 
1176
            do
 
1177
            {
 
1178
                printToken(__it->element, "expr", "echoExprs[]");
 
1179
                __it = __it->next;
 
1180
            }
 
1181
            while (__it != __end);
 
1182
        }
 
1183
        if (node->throwExpr) printToken(node->throwExpr, "expr", "throwExpr");
 
1184
        m_indent++;
 
1185
        DefaultVisitor::visitStatement(node);
 
1186
        m_indent--;
 
1187
    }
 
1188
 
 
1189
    virtual void visitStaticArrayPairValue(StaticArrayPairValueAst *node)
 
1190
    {
 
1191
        if (!m_indent) printToken(node, "staticArrayPairValue");
 
1192
        if (node->val1Sequence)
 
1193
        {
 
1194
            const KDevPG::ListNode<StaticScalarAst*> *__it = node->val1Sequence->front(), *__end = __it;
 
1195
            do
 
1196
            {
 
1197
                printToken(__it->element, "staticScalar", "val1[]");
 
1198
                __it = __it->next;
 
1199
            }
 
1200
            while (__it != __end);
 
1201
        }
 
1202
        if (node->val2Sequence)
 
1203
        {
 
1204
            const KDevPG::ListNode<StaticScalarAst*> *__it = node->val2Sequence->front(), *__end = __it;
 
1205
            do
 
1206
            {
 
1207
                printToken(__it->element, "staticScalar", "val2[]");
 
1208
                __it = __it->next;
 
1209
            }
 
1210
            while (__it != __end);
 
1211
        }
 
1212
        m_indent++;
 
1213
        DefaultVisitor::visitStaticArrayPairValue(node);
 
1214
        m_indent--;
 
1215
    }
 
1216
 
 
1217
    virtual void visitStaticMember(StaticMemberAst *node)
 
1218
    {
 
1219
        if (!m_indent) printToken(node, "staticMember");
 
1220
        if (node->className) printToken(node->className, "identifier", "className");
 
1221
        if (node->variable) printToken(node->variable, "variableWithoutObjects", "variable");
 
1222
        m_indent++;
 
1223
        DefaultVisitor::visitStaticMember(node);
 
1224
        m_indent--;
 
1225
    }
 
1226
 
 
1227
    virtual void visitStaticScalar(StaticScalarAst *node)
 
1228
    {
 
1229
        if (!m_indent) printToken(node, "staticScalar");
 
1230
        if (node->value) printToken(node->value, "commonScalar", "value");
 
1231
        if (node->constantOrClassConst) printToken(node->constantOrClassConst, "constantOrClassConst", "constantOrClassConst");
 
1232
        if (node->plusValue) printToken(node->plusValue, "staticScalar", "plusValue");
 
1233
        if (node->minusValue) printToken(node->minusValue, "staticScalar", "minusValue");
 
1234
        if (node->arrayValuesSequence)
 
1235
        {
 
1236
            const KDevPG::ListNode<StaticArrayPairValueAst*> *__it = node->arrayValuesSequence->front(), *__end = __it;
 
1237
            do
 
1238
            {
 
1239
                printToken(__it->element, "staticArrayPairValue", "arrayValues[]");
 
1240
                __it = __it->next;
 
1241
            }
 
1242
            while (__it != __end);
 
1243
        }
 
1244
        m_indent++;
 
1245
        DefaultVisitor::visitStaticScalar(node);
 
1246
        m_indent--;
 
1247
    }
 
1248
 
 
1249
    virtual void visitStaticVar(StaticVarAst *node)
 
1250
    {
 
1251
        if (!m_indent) printToken(node, "staticVar");
 
1252
        if (node->var) printToken(node->var, "variableIdentifier", "var");
 
1253
        if (node->value) printToken(node->value, "staticScalar", "value");
 
1254
        m_indent++;
 
1255
        DefaultVisitor::visitStaticVar(node);
 
1256
        m_indent--;
 
1257
    }
 
1258
 
 
1259
    virtual void visitSwitchCaseList(SwitchCaseListAst *node)
 
1260
    {
 
1261
        if (!m_indent) printToken(node, "switchCaseList");
 
1262
        if (node->caseList) printToken(node->caseList, "caseList", "caseList");
 
1263
        m_indent++;
 
1264
        DefaultVisitor::visitSwitchCaseList(node);
 
1265
        m_indent--;
 
1266
    }
 
1267
 
 
1268
    virtual void visitTopStatement(TopStatementAst *node)
 
1269
    {
 
1270
        if (!m_indent) printToken(node, "topStatement");
 
1271
        if (node->statement) printToken(node->statement, "statement", "statement");
 
1272
        if (node->functionDeclaration) printToken(node->functionDeclaration, "functionDeclarationStatement", "functionDeclaration");
 
1273
        if (node->classDeclaration) printToken(node->classDeclaration, "classDeclarationStatement", "classDeclaration");
 
1274
        if (node->interfaceDeclaration) printToken(node->interfaceDeclaration, "interfaceDeclarationStatement", "interfaceDeclaration");
 
1275
        m_indent++;
 
1276
        DefaultVisitor::visitTopStatement(node);
 
1277
        m_indent--;
 
1278
    }
 
1279
 
 
1280
    virtual void visitUnaryExpression(UnaryExpressionAst *node)
 
1281
    {
 
1282
        if (!m_indent) printToken(node, "unaryExpression");
 
1283
        if (node->unaryExpression) printToken(node->unaryExpression, "unaryExpression", "unaryExpression");
 
1284
        if (node->assignmentList) printToken(node->assignmentList, "assignmentList", "assignmentList");
 
1285
        if (node->expression) printToken(node->expression, "expr", "expression");
 
1286
        if (node->includeExpression) printToken(node->includeExpression, "unaryExpression", "includeExpression");
 
1287
        if (node->unaryExpressionNotPlusminus) printToken(node->unaryExpressionNotPlusminus, "unaryExpressionNotPlusminus", "unaryExpressionNotPlusminus");
 
1288
        m_indent++;
 
1289
        DefaultVisitor::visitUnaryExpression(node);
 
1290
        m_indent--;
 
1291
    }
 
1292
 
 
1293
    virtual void visitUnaryExpressionNotPlusminus(UnaryExpressionNotPlusminusAst *node)
 
1294
    {
 
1295
        if (!m_indent) printToken(node, "unaryExpressionNotPlusminus");
 
1296
        if (node->prefixOperatorSequence)
 
1297
        {
 
1298
            const KDevPG::ListNode<PostprefixOperatorAst*> *__it = node->prefixOperatorSequence->front(), *__end = __it;
 
1299
            do
 
1300
            {
 
1301
                printToken(__it->element, "postprefixOperator", "prefixOperator[]");
 
1302
                __it = __it->next;
 
1303
            }
 
1304
            while (__it != __end);
 
1305
        }
 
1306
        if (node->varExpression) printToken(node->varExpression, "varExpression", "varExpression");
 
1307
        if (node->postfixOperatorSequence)
 
1308
        {
 
1309
            const KDevPG::ListNode<PostprefixOperatorAst*> *__it = node->postfixOperatorSequence->front(), *__end = __it;
 
1310
            do
 
1311
            {
 
1312
                printToken(__it->element, "postprefixOperator", "postfixOperator[]");
 
1313
                __it = __it->next;
 
1314
            }
 
1315
            while (__it != __end);
 
1316
        }
 
1317
        m_indent++;
 
1318
        DefaultVisitor::visitUnaryExpressionNotPlusminus(node);
 
1319
        m_indent--;
 
1320
    }
 
1321
 
 
1322
    virtual void visitVarExpression(VarExpressionAst *node)
 
1323
    {
 
1324
        if (!m_indent) printToken(node, "varExpression");
 
1325
        if (node->variable) printToken(node->variable, "variable", "variable");
 
1326
        if (node->newObject) printToken(node->newObject, "varExpressionNewObject", "newObject");
 
1327
        if (node->varExpressionNormal) printToken(node->varExpressionNormal, "varExpressionNormal", "varExpressionNormal");
 
1328
        m_indent++;
 
1329
        DefaultVisitor::visitVarExpression(node);
 
1330
        m_indent--;
 
1331
    }
 
1332
 
 
1333
    virtual void visitVarExpressionNewObject(VarExpressionNewObjectAst *node)
 
1334
    {
 
1335
        if (!m_indent) printToken(node, "varExpressionNewObject");
 
1336
        if (node->className) printToken(node->className, "classNameReference", "className");
 
1337
        if (node->ctor) printToken(node->ctor, "ctorArguments", "ctor");
 
1338
        m_indent++;
 
1339
        DefaultVisitor::visitVarExpressionNewObject(node);
 
1340
        m_indent--;
 
1341
    }
 
1342
 
 
1343
    virtual void visitVarExpressionNormal(VarExpressionNormalAst *node)
 
1344
    {
 
1345
        if (!m_indent) printToken(node, "varExpressionNormal");
 
1346
        if (node->expression) printToken(node->expression, "expr", "expression");
 
1347
        if (node->encapsList) printToken(node->encapsList, "encapsList", "encapsList");
 
1348
        if (node->variable) printToken(node->variable, "variable", "variable");
 
1349
        if (node->scalar) printToken(node->scalar, "scalar", "scalar");
 
1350
        if (node->arrayValuesSequence)
 
1351
        {
 
1352
            const KDevPG::ListNode<ArrayPairValueAst*> *__it = node->arrayValuesSequence->front(), *__end = __it;
 
1353
            do
 
1354
            {
 
1355
                printToken(__it->element, "arrayPairValue", "arrayValues[]");
 
1356
                __it = __it->next;
 
1357
            }
 
1358
            while (__it != __end);
 
1359
        }
 
1360
        if (node->issetVariableSequence)
 
1361
        {
 
1362
            const KDevPG::ListNode<VariableAst*> *__it = node->issetVariableSequence->front(), *__end = __it;
 
1363
            do
 
1364
            {
 
1365
                printToken(__it->element, "variable", "issetVariable[]");
 
1366
                __it = __it->next;
 
1367
            }
 
1368
            while (__it != __end);
 
1369
        }
 
1370
        if (node->emptyVarialbe) printToken(node->emptyVarialbe, "variable", "emptyVarialbe");
 
1371
        if (node->newObject) printToken(node->newObject, "varExpressionNewObject", "newObject");
 
1372
        if (node->cloneCar) printToken(node->cloneCar, "varExpressionNormal", "cloneCar");
 
1373
        m_indent++;
 
1374
        DefaultVisitor::visitVarExpressionNormal(node);
 
1375
        m_indent--;
 
1376
    }
 
1377
 
 
1378
    virtual void visitVariable(VariableAst *node)
 
1379
    {
 
1380
        if (!m_indent) printToken(node, "variable");
 
1381
        if (node->var) printToken(node->var, "baseVariableWithFunctionCalls", "var");
 
1382
        if (node->variablePropertiesSequence)
 
1383
        {
 
1384
            const KDevPG::ListNode<VariablePropertyAst*> *__it = node->variablePropertiesSequence->front(), *__end = __it;
 
1385
            do
 
1386
            {
 
1387
                printToken(__it->element, "variableProperty", "variableProperties[]");
 
1388
                __it = __it->next;
 
1389
            }
 
1390
            while (__it != __end);
 
1391
        }
 
1392
        m_indent++;
 
1393
        DefaultVisitor::visitVariable(node);
 
1394
        m_indent--;
 
1395
    }
 
1396
 
 
1397
    virtual void visitVariableIdentifier(VariableIdentifierAst *node)
 
1398
    {
 
1399
        if (!m_indent) printToken(node, "variableIdentifier");
 
1400
        m_indent++;
 
1401
        DefaultVisitor::visitVariableIdentifier(node);
 
1402
        m_indent--;
 
1403
    }
 
1404
 
 
1405
    virtual void visitVariableName(VariableNameAst *node)
 
1406
    {
 
1407
        if (!m_indent) printToken(node, "variableName");
 
1408
        if (node->name) printToken(node->name, "identifier", "name");
 
1409
        if (node->expr) printToken(node->expr, "expr", "expr");
 
1410
        m_indent++;
 
1411
        DefaultVisitor::visitVariableName(node);
 
1412
        m_indent--;
 
1413
    }
 
1414
 
 
1415
    virtual void visitVariableProperty(VariablePropertyAst *node)
 
1416
    {
 
1417
        if (!m_indent) printToken(node, "variableProperty");
 
1418
        if (node->objectProperty) printToken(node->objectProperty, "objectProperty", "objectProperty");
 
1419
        if (node->parameterList) printToken(node->parameterList, "functionCallParameterList", "parameterList");
 
1420
        m_indent++;
 
1421
        DefaultVisitor::visitVariableProperty(node);
 
1422
        m_indent--;
 
1423
    }
 
1424
 
 
1425
    virtual void visitVariableWithoutObjects(VariableWithoutObjectsAst *node)
 
1426
    {
 
1427
        if (!m_indent) printToken(node, "variableWithoutObjects");
 
1428
        if (node->variable) printToken(node->variable, "compoundVariableWithSimpleIndirectReference", "variable");
 
1429
        if (node->offsetItemsSequence)
 
1430
        {
 
1431
            const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
 
1432
            do
 
1433
            {
 
1434
                printToken(__it->element, "dimListItem", "offsetItems[]");
 
1435
                __it = __it->next;
 
1436
            }
 
1437
            while (__it != __end);
 
1438
        }
 
1439
        m_indent++;
 
1440
        DefaultVisitor::visitVariableWithoutObjects(node);
 
1441
        m_indent--;
 
1442
    }
 
1443
 
 
1444
    virtual void visitWhileStatement(WhileStatementAst *node)
 
1445
    {
 
1446
        if (!m_indent) printToken(node, "whileStatement");
 
1447
        if (node->statement) printToken(node->statement, "statement", "statement");
 
1448
        if (node->statements) printToken(node->statements, "innerStatementList", "statements");
 
1449
        m_indent++;
 
1450
        DefaultVisitor::visitWhileStatement(node);
 
1451
        m_indent--;
 
1452
    }
 
1453
 
 
1454
private:
 
1455
    void printToken(AstNode *node, const QString &mType, const QString &mName = QString())
 
1456
    {
 
1457
        QString tokenString;
 
1458
        if (!m_content.isEmpty())
 
1459
        {
 
1460
            TokenStream::Token startToken = m_str->token(node->startToken);
 
1461
            TokenStream::Token endToken = m_str->token(node->endToken);
 
1462
            int begin = startToken.begin;
 
1463
            int end = endToken.end;
 
1464
            if (end-begin > 30)
 
1465
            {
 
1466
                tokenString = m_content.mid(begin, 10);
 
1467
                tokenString += " ...";
 
1468
                tokenString += QString("%1 more").arg(end-begin-20);
 
1469
                tokenString += "... ";
 
1470
                tokenString += m_content.mid(end-10, 10);
 
1471
            }
 
1472
            else
 
1473
            {
 
1474
                tokenString = m_content.mid(begin, end-begin+1);
 
1475
            }
 
1476
            tokenString = tokenString.replace('\n', "\\n");
 
1477
            tokenString = tokenString.replace('\r', "\\r");
 
1478
        }
 
1479
        qint64 beginLine,endLine,beginCol,endCol;
 
1480
        m_str->startPosition(node->startToken, &beginLine, &beginCol);
 
1481
        m_str->endPosition(node->endToken, &endLine, &endCol);
 
1482
        qDebug() << QString().fill(' ', m_indent) + mName + (!mName.isEmpty() ? "->" : "") + mType + "[" << m_str->token( node->startToken ).begin << "," << beginLine << "," << beginCol << "] --- [" << m_str->token( node->endToken ).end << "," << endLine << "," << endCol << "] " << tokenString;
 
1483
    }
 
1484
    TokenStream *m_str;
 
1485
    int m_indent;
 
1486
    QString m_content;
 
1487
};
 
1488
 
 
1489
} // end of namespace Php
 
1490
 
 
1491
#endif
 
1492