Mercurial > hg > CbC > CbC_gcc

comparison gcc/d/dmd/visitor.h @ 145:1830386684a0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc-9.2.0
author anatofuz
date Thu, 13 Feb 2020 11:34:05 +0900
parents
children
comparison
equal deleted inserted replaced
131:84e7813d76e9 145:1830386684a0
1
2 /* Compiler implementation of the D programming language
3 * Copyright (C) 2013-2019 by The D Language Foundation, All Rights Reserved
4 * http://www.digitalmars.com
5 * Distributed under the Boost Software License, Version 1.0.
6 * http://www.boost.org/LICENSE_1_0.txt
7 * https://github.com/dlang/dmd/blob/master/src/dmd/visitor.h
8 */
9
10 #pragma once
11
12 #include "root/dsystem.h"
13
14 class Statement;
15 class ErrorStatement;
16 class PeelStatement;
17 class ExpStatement;
18 class DtorExpStatement;
19 class CompileStatement;
20 class CompoundStatement;
21 class CompoundDeclarationStatement;
22 class UnrolledLoopStatement;
23 class ScopeStatement;
24 class ForwardingStatement;
25 class WhileStatement;
26 class DoStatement;
27 class ForStatement;
28 class ForeachStatement;
29 class ForeachRangeStatement;
30 class StaticForeachStatement;
31 class IfStatement;
32 class ConditionalStatement;
33 class PragmaStatement;
34 class StaticAssertStatement;
35 class SwitchStatement;
36 class CaseStatement;
37 class CaseRangeStatement;
38 class DefaultStatement;
39 class GotoDefaultStatement;
40 class GotoCaseStatement;
41 class SwitchErrorStatement;
42 class ReturnStatement;
43 class BreakStatement;
44 class ContinueStatement;
45 class SynchronizedStatement;
46 class WithStatement;
47 class TryCatchStatement;
48 class TryFinallyStatement;
49 class OnScopeStatement;
50 class ThrowStatement;
51 class DebugStatement;
52 class GotoStatement;
53 class LabelStatement;
54 class AsmStatement;
55 class InlineAsmStatement;
56 class GccAsmStatement;
57 class CompoundAsmStatement;
58 class ImportStatement;
59
60 class Type;
61 class TypeError;
62 class TypeNext;
63 class TypeBasic;
64 class TypeVector;
65 class TypeArray;
66 class TypeSArray;
67 class TypeDArray;
68 class TypeAArray;
69 class TypePointer;
70 class TypeReference;
71 class TypeFunction;
72 class TypeDelegate;
73 class TypeQualified;
74 class TypeIdentifier;
75 class TypeInstance;
76 class TypeTypeof;
77 class TypeReturn;
78 class TypeStruct;
79 class TypeEnum;
80 class TypeClass;
81 class TypeTuple;
82 class TypeSlice;
83 class TypeNull;
84
85 class Dsymbol;
86
87 class StaticAssert;
88 class DebugSymbol;
89 class VersionSymbol;
90 class EnumMember;
91 class Import;
92 class OverloadSet;
93 class LabelDsymbol;
94 class AliasThis;
95
96 class AttribDeclaration;
97 class StorageClassDeclaration;
98 class DeprecatedDeclaration;
99 class LinkDeclaration;
100 class CPPMangleDeclaration;
101 class ProtDeclaration;
102 class AlignDeclaration;
103 class AnonDeclaration;
104 class PragmaDeclaration;
105 class ConditionalDeclaration;
106 class StaticIfDeclaration;
107 class CompileDeclaration;
108 class StaticForeachDeclaration;
109 class UserAttributeDeclaration;
110
111 class ScopeDsymbol;
112 class TemplateDeclaration;
113 class TemplateInstance;
114 class TemplateMixin;
115 class EnumDeclaration;
116 class Package;
117 class Module;
118 class WithScopeSymbol;
119 class ArrayScopeSymbol;
120 class Nspace;
121
122 class AggregateDeclaration;
123 class StructDeclaration;
124 class UnionDeclaration;
125 class ClassDeclaration;
126 class InterfaceDeclaration;
127
128 class Declaration;
129 class TupleDeclaration;
130 class AliasDeclaration;
131 class OverDeclaration;
132 class VarDeclaration;
133 class SymbolDeclaration;
134 class ThisDeclaration;
135
136 class TypeInfoDeclaration;
137 class TypeInfoStructDeclaration;
138 class TypeInfoClassDeclaration;
139 class TypeInfoInterfaceDeclaration;
140 class TypeInfoPointerDeclaration;
141 class TypeInfoArrayDeclaration;
142 class TypeInfoStaticArrayDeclaration;
143 class TypeInfoAssociativeArrayDeclaration;
144 class TypeInfoEnumDeclaration;
145 class TypeInfoFunctionDeclaration;
146 class TypeInfoDelegateDeclaration;
147 class TypeInfoTupleDeclaration;
148 class TypeInfoConstDeclaration;
149 class TypeInfoInvariantDeclaration;
150 class TypeInfoSharedDeclaration;
151 class TypeInfoWildDeclaration;
152 class TypeInfoVectorDeclaration;
153
154 class FuncDeclaration;
155 class FuncAliasDeclaration;
156 class FuncLiteralDeclaration;
157 class CtorDeclaration;
158 class PostBlitDeclaration;
159 class DtorDeclaration;
160 class StaticCtorDeclaration;
161 class SharedStaticCtorDeclaration;
162 class StaticDtorDeclaration;
163 class SharedStaticDtorDeclaration;
164 class InvariantDeclaration;
165 class UnitTestDeclaration;
166 class NewDeclaration;
167 class DeleteDeclaration;
168
169 class Initializer;
170 class VoidInitializer;
171 class ErrorInitializer;
172 class StructInitializer;
173 class ArrayInitializer;
174 class ExpInitializer;
175
176 class Expression;
177 class IntegerExp;
178 class ErrorExp;
179 class RealExp;
180 class ComplexExp;
181 class IdentifierExp;
182 class DollarExp;
183 class DsymbolExp;
184 class ThisExp;
185 class SuperExp;
186 class NullExp;
187 class StringExp;
188 class TupleExp;
189 class ArrayLiteralExp;
190 class AssocArrayLiteralExp;
191 class StructLiteralExp;
192 class TypeExp;
193 class ScopeExp;
194 class TemplateExp;
195 class NewExp;
196 class NewAnonClassExp;
197 class SymbolExp;
198 class SymOffExp;
199 class VarExp;
200 class OverExp;
201 class FuncExp;
202 class DeclarationExp;
203 class TypeidExp;
204 class TraitsExp;
205 class HaltExp;
206 class IsExp;
207 class UnaExp;
208 class BinExp;
209 class BinAssignExp;
210 class CompileExp;
211 class ImportExp;
212 class AssertExp;
213 class DotIdExp;
214 class DotTemplateExp;
215 class DotVarExp;
216 class DotTemplateInstanceExp;
217 class DelegateExp;
218 class DotTypeExp;
219 class CallExp;
220 class AddrExp;
221 class PtrExp;
222 class NegExp;
223 class UAddExp;
224 class ComExp;
225 class NotExp;
226 class DeleteExp;
227 class CastExp;
228 class VectorExp;
229 class VectorArrayExp;
230 class SliceExp;
231 class ArrayLengthExp;
232 class IntervalExp;
233 class DelegatePtrExp;
234 class DelegateFuncptrExp;
235 class ArrayExp;
236 class DotExp;
237 class CommaExp;
238 class IndexExp;
239 class PostExp;
240 class PreExp;
241 class AssignExp;
242 class ConstructExp;
243 class BlitExp;
244 class AddAssignExp;
245 class MinAssignExp;
246 class MulAssignExp;
247 class DivAssignExp;
248 class ModAssignExp;
249 class AndAssignExp;
250 class OrAssignExp;
251 class XorAssignExp;
252 class PowAssignExp;
253 class ShlAssignExp;
254 class ShrAssignExp;
255 class UshrAssignExp;
256 class CatAssignExp;
257 class AddExp;
258 class MinExp;
259 class CatExp;
260 class MulExp;
261 class DivExp;
262 class ModExp;
263 class PowExp;
264 class ShlExp;
265 class ShrExp;
266 class UshrExp;
267 class AndExp;
268 class OrExp;
269 class XorExp;
270 class OrOrExp;
271 class AndAndExp;
272 class CmpExp;
273 class InExp;
274 class RemoveExp;
275 class EqualExp;
276 class IdentityExp;
277 class CondExp;
278 class DefaultInitExp;
279 class FileInitExp;
280 class LineInitExp;
281 class ModuleInitExp;
282 class FuncInitExp;
283 class PrettyFuncInitExp;
284 class ClassReferenceExp;
285 class VoidInitExp;
286 class ThrownExceptionExp;
287
288 class TemplateParameter;
289 class TemplateTypeParameter;
290 class TemplateThisParameter;
291 class TemplateValueParameter;
292 class TemplateAliasParameter;
293 class TemplateTupleParameter;
294
295 class Condition;
296 class DVCondition;
297 class DebugCondition;
298 class VersionCondition;
299 class StaticIfCondition;
300
301 class Parameter;
302
303 class Visitor
304 {
305 public:
306 virtual void visit(Statement *) { assert(0); }
307 virtual void visit(ErrorStatement *s) { visit((Statement *)s); }
308 virtual void visit(PeelStatement *s) { visit((Statement *)s); }
309 virtual void visit(ExpStatement *s) { visit((Statement *)s); }
310 virtual void visit(DtorExpStatement *s) { visit((ExpStatement *)s); }
311 virtual void visit(CompileStatement *s) { visit((Statement *)s); }
312 virtual void visit(CompoundStatement *s) { visit((Statement *)s); }
313 virtual void visit(CompoundDeclarationStatement *s) { visit((CompoundStatement *)s); }
314 virtual void visit(UnrolledLoopStatement *s) { visit((Statement *)s); }
315 virtual void visit(ScopeStatement *s) { visit((Statement *)s); }
316 virtual void visit(ForwardingStatement *s) { visit((Statement *)s); }
317 virtual void visit(WhileStatement *s) { visit((Statement *)s); }
318 virtual void visit(DoStatement *s) { visit((Statement *)s); }
319 virtual void visit(ForStatement *s) { visit((Statement *)s); }
320 virtual void visit(ForeachStatement *s) { visit((Statement *)s); }
321 virtual void visit(ForeachRangeStatement *s) { visit((Statement *)s); }
322 virtual void visit(StaticForeachStatement *s) { visit((Statement *)s); }
323 virtual void visit(IfStatement *s) { visit((Statement *)s); }
324 virtual void visit(ConditionalStatement *s) { visit((Statement *)s); }
325 virtual void visit(PragmaStatement *s) { visit((Statement *)s); }
326 virtual void visit(StaticAssertStatement *s) { visit((Statement *)s); }
327 virtual void visit(SwitchStatement *s) { visit((Statement *)s); }
328 virtual void visit(CaseStatement *s) { visit((Statement *)s); }
329 virtual void visit(CaseRangeStatement *s) { visit((Statement *)s); }
330 virtual void visit(DefaultStatement *s) { visit((Statement *)s); }
331 virtual void visit(GotoDefaultStatement *s) { visit((Statement *)s); }
332 virtual void visit(GotoCaseStatement *s) { visit((Statement *)s); }
333 virtual void visit(SwitchErrorStatement *s) { visit((Statement *)s); }
334 virtual void visit(ReturnStatement *s) { visit((Statement *)s); }
335 virtual void visit(BreakStatement *s) { visit((Statement *)s); }
336 virtual void visit(ContinueStatement *s) { visit((Statement *)s); }
337 virtual void visit(SynchronizedStatement *s) { visit((Statement *)s); }
338 virtual void visit(WithStatement *s) { visit((Statement *)s); }
339 virtual void visit(TryCatchStatement *s) { visit((Statement *)s); }
340 virtual void visit(TryFinallyStatement *s) { visit((Statement *)s); }
341 virtual void visit(OnScopeStatement *s) { visit((Statement *)s); }
342 virtual void visit(ThrowStatement *s) { visit((Statement *)s); }
343 virtual void visit(DebugStatement *s) { visit((Statement *)s); }
344 virtual void visit(GotoStatement *s) { visit((Statement *)s); }
345 virtual void visit(LabelStatement *s) { visit((Statement *)s); }
346 virtual void visit(AsmStatement *s) { visit((Statement *)s); }
347 virtual void visit(InlineAsmStatement *s) { visit((AsmStatement *)s); }
348 virtual void visit(GccAsmStatement *s) { visit((AsmStatement *)s); }
349 virtual void visit(CompoundAsmStatement *s) { visit((CompoundStatement *)s); }
350 virtual void visit(ImportStatement *s) { visit((Statement *)s); }
351
352 virtual void visit(Type *) { assert(0); }
353 virtual void visit(TypeError *t) { visit((Type *)t); }
354 virtual void visit(TypeNext *t) { visit((Type *)t); }
355 virtual void visit(TypeBasic *t) { visit((Type *)t); }
356 virtual void visit(TypeVector *t) { visit((Type *)t); }
357 virtual void visit(TypeArray *t) { visit((TypeNext *)t); }
358 virtual void visit(TypeSArray *t) { visit((TypeArray *)t); }
359 virtual void visit(TypeDArray *t) { visit((TypeArray *)t); }
360 virtual void visit(TypeAArray *t) { visit((TypeArray *)t); }
361 virtual void visit(TypePointer *t) { visit((TypeNext *)t); }
362 virtual void visit(TypeReference *t) { visit((TypeNext *)t); }
363 virtual void visit(TypeFunction *t) { visit((TypeNext *)t); }
364 virtual void visit(TypeDelegate *t) { visit((TypeNext *)t); }
365 virtual void visit(TypeQualified *t) { visit((Type *)t); }
366 virtual void visit(TypeIdentifier *t) { visit((TypeQualified *)t); }
367 virtual void visit(TypeInstance *t) { visit((TypeQualified *)t); }
368 virtual void visit(TypeTypeof *t) { visit((TypeQualified *)t); }
369 virtual void visit(TypeReturn *t) { visit((TypeQualified *)t); }
370 virtual void visit(TypeStruct *t) { visit((Type *)t); }
371 virtual void visit(TypeEnum *t) { visit((Type *)t); }
372 virtual void visit(TypeClass *t) { visit((Type *)t); }
373 virtual void visit(TypeTuple *t) { visit((Type *)t); }
374 virtual void visit(TypeSlice *t) { visit((TypeNext *)t); }
375 virtual void visit(TypeNull *t) { visit((Type *)t); }
376
377 virtual void visit(Dsymbol *) { assert(0); }
378
379 virtual void visit(StaticAssert *s) { visit((Dsymbol *)s); }
380 virtual void visit(DebugSymbol *s) { visit((Dsymbol *)s); }
381 virtual void visit(VersionSymbol *s) { visit((Dsymbol *)s); }
382 virtual void visit(EnumMember *s) { visit((VarDeclaration *)s); }
383 virtual void visit(Import *s) { visit((Dsymbol *)s); }
384 virtual void visit(OverloadSet *s) { visit((Dsymbol *)s); }
385 virtual void visit(LabelDsymbol *s) { visit((Dsymbol *)s); }
386 virtual void visit(AliasThis *s) { visit((Dsymbol *)s); }
387
388 virtual void visit(AttribDeclaration *s) { visit((Dsymbol *)s); }
389 virtual void visit(StorageClassDeclaration *s) { visit((AttribDeclaration *)s); }
390 virtual void visit(DeprecatedDeclaration *s) { visit((StorageClassDeclaration *)s); }
391 virtual void visit(LinkDeclaration *s) { visit((AttribDeclaration *)s); }
392 virtual void visit(CPPMangleDeclaration *s) { visit((AttribDeclaration *)s); }
393 virtual void visit(ProtDeclaration *s) { visit((AttribDeclaration *)s); }
394 virtual void visit(AlignDeclaration *s) { visit((AttribDeclaration *)s); }
395 virtual void visit(AnonDeclaration *s) { visit((AttribDeclaration *)s); }
396 virtual void visit(PragmaDeclaration *s) { visit((AttribDeclaration *)s); }
397 virtual void visit(ConditionalDeclaration *s) { visit((AttribDeclaration *)s); }
398 virtual void visit(StaticIfDeclaration *s) { visit((ConditionalDeclaration *)s); }
399 virtual void visit(StaticForeachDeclaration *s) { visit((AttribDeclaration *)s); }
400 virtual void visit(CompileDeclaration *s) { visit((AttribDeclaration *)s); }
401 virtual void visit(UserAttributeDeclaration *s) { visit((AttribDeclaration *)s); }
402
403 virtual void visit(ScopeDsymbol *s) { visit((Dsymbol *)s); }
404 virtual void visit(TemplateDeclaration *s) { visit((ScopeDsymbol *)s); }
405 virtual void visit(TemplateInstance *s) { visit((ScopeDsymbol *)s); }
406 virtual void visit(TemplateMixin *s) { visit((TemplateInstance *)s); }
407 virtual void visit(EnumDeclaration *s) { visit((ScopeDsymbol *)s); }
408 virtual void visit(Package *s) { visit((ScopeDsymbol *)s); }
409 virtual void visit(Module *s) { visit((Package *)s); }
410 virtual void visit(WithScopeSymbol *s) { visit((ScopeDsymbol *)s); }
411 virtual void visit(ArrayScopeSymbol *s) { visit((ScopeDsymbol *)s); }
412 virtual void visit(Nspace *s) { visit((ScopeDsymbol *)s); }
413
414 virtual void visit(AggregateDeclaration *s) { visit((ScopeDsymbol *)s); }
415 virtual void visit(StructDeclaration *s) { visit((AggregateDeclaration *)s); }
416 virtual void visit(UnionDeclaration *s) { visit((StructDeclaration *)s); }
417 virtual void visit(ClassDeclaration *s) { visit((AggregateDeclaration *)s); }
418 virtual void visit(InterfaceDeclaration *s) { visit((ClassDeclaration *)s); }
419
420 virtual void visit(Declaration *s) { visit((Dsymbol *)s); }
421 virtual void visit(TupleDeclaration *s) { visit((Declaration *)s); }
422 virtual void visit(AliasDeclaration *s) { visit((Declaration *)s); }
423 virtual void visit(OverDeclaration *s) { visit((Declaration *)s); }
424 virtual void visit(VarDeclaration *s) { visit((Declaration *)s); }
425 virtual void visit(SymbolDeclaration *s) { visit((Declaration *)s); }
426 virtual void visit(ThisDeclaration *s) { visit((VarDeclaration *)s); }
427
428 virtual void visit(TypeInfoDeclaration *s) { visit((VarDeclaration *)s); }
429 virtual void visit(TypeInfoStructDeclaration *s) { visit((TypeInfoDeclaration *)s); }
430 virtual void visit(TypeInfoClassDeclaration *s) { visit((TypeInfoDeclaration *)s); }
431 virtual void visit(TypeInfoInterfaceDeclaration *s) { visit((TypeInfoDeclaration *)s); }
432 virtual void visit(TypeInfoPointerDeclaration *s) { visit((TypeInfoDeclaration *)s); }
433 virtual void visit(TypeInfoArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); }
434 virtual void visit(TypeInfoStaticArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); }
435 virtual void visit(TypeInfoAssociativeArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); }
436 virtual void visit(TypeInfoEnumDeclaration *s) { visit((TypeInfoDeclaration *)s); }
437 virtual void visit(TypeInfoFunctionDeclaration *s) { visit((TypeInfoDeclaration *)s); }
438 virtual void visit(TypeInfoDelegateDeclaration *s) { visit((TypeInfoDeclaration *)s); }
439 virtual void visit(TypeInfoTupleDeclaration *s) { visit((TypeInfoDeclaration *)s); }
440 virtual void visit(TypeInfoConstDeclaration *s) { visit((TypeInfoDeclaration *)s); }
441 virtual void visit(TypeInfoInvariantDeclaration *s) { visit((TypeInfoDeclaration *)s); }
442 virtual void visit(TypeInfoSharedDeclaration *s) { visit((TypeInfoDeclaration *)s); }
443 virtual void visit(TypeInfoWildDeclaration *s) { visit((TypeInfoDeclaration *)s); }
444 virtual void visit(TypeInfoVectorDeclaration *s) { visit((TypeInfoDeclaration *)s); }
445
446 virtual void visit(FuncDeclaration *s) { visit((Declaration *)s); }
447 virtual void visit(FuncAliasDeclaration *s) { visit((FuncDeclaration *)s); }
448 virtual void visit(FuncLiteralDeclaration *s) { visit((FuncDeclaration *)s); }
449 virtual void visit(CtorDeclaration *s) { visit((FuncDeclaration *)s); }
450 virtual void visit(PostBlitDeclaration *s) { visit((FuncDeclaration *)s); }
451 virtual void visit(DtorDeclaration *s) { visit((FuncDeclaration *)s); }
452 virtual void visit(StaticCtorDeclaration *s) { visit((FuncDeclaration *)s); }
453 virtual void visit(SharedStaticCtorDeclaration *s) { visit((StaticCtorDeclaration *)s); }
454 virtual void visit(StaticDtorDeclaration *s) { visit((FuncDeclaration *)s); }
455 virtual void visit(SharedStaticDtorDeclaration *s) { visit((StaticDtorDeclaration *)s); }
456 virtual void visit(InvariantDeclaration *s) { visit((FuncDeclaration *)s); }
457 virtual void visit(UnitTestDeclaration *s) { visit((FuncDeclaration *)s); }
458 virtual void visit(NewDeclaration *s) { visit((FuncDeclaration *)s); }
459 virtual void visit(DeleteDeclaration *s) { visit((FuncDeclaration *)s); }
460
461 virtual void visit(Initializer *) { assert(0); }
462 virtual void visit(VoidInitializer *i) { visit((Initializer *)i); }
463 virtual void visit(ErrorInitializer *i) { visit((Initializer *)i); }
464 virtual void visit(StructInitializer *i) { visit((Initializer *)i); }
465 virtual void visit(ArrayInitializer *i) { visit((Initializer *)i); }
466 virtual void visit(ExpInitializer *i) { visit((Initializer *)i); }
467
468 virtual void visit(Expression *) { assert(0); }
469 virtual void visit(IntegerExp *e) { visit((Expression *)e); }
470 virtual void visit(ErrorExp *e) { visit((Expression *)e); }
471 virtual void visit(RealExp *e) { visit((Expression *)e); }
472 virtual void visit(ComplexExp *e) { visit((Expression *)e); }
473 virtual void visit(IdentifierExp *e) { visit((Expression *)e); }
474 virtual void visit(DollarExp *e) { visit((IdentifierExp *)e); }
475 virtual void visit(DsymbolExp *e) { visit((Expression *)e); }
476 virtual void visit(ThisExp *e) { visit((Expression *)e); }
477 virtual void visit(SuperExp *e) { visit((ThisExp *)e); }
478 virtual void visit(NullExp *e) { visit((Expression *)e); }
479 virtual void visit(StringExp *e) { visit((Expression *)e); }
480 virtual void visit(TupleExp *e) { visit((Expression *)e); }
481 virtual void visit(ArrayLiteralExp *e) { visit((Expression *)e); }
482 virtual void visit(AssocArrayLiteralExp *e) { visit((Expression *)e); }
483 virtual void visit(StructLiteralExp *e) { visit((Expression *)e); }
484 virtual void visit(TypeExp *e) { visit((Expression *)e); }
485 virtual void visit(ScopeExp *e) { visit((Expression *)e); }
486 virtual void visit(TemplateExp *e) { visit((Expression *)e); }
487 virtual void visit(NewExp *e) { visit((Expression *)e); }
488 virtual void visit(NewAnonClassExp *e) { visit((Expression *)e); }
489 virtual void visit(SymbolExp *e) { visit((Expression *)e); }
490 virtual void visit(SymOffExp *e) { visit((SymbolExp *)e); }
491 virtual void visit(VarExp *e) { visit((SymbolExp *)e); }
492 virtual void visit(OverExp *e) { visit((Expression *)e); }
493 virtual void visit(FuncExp *e) { visit((Expression *)e); }
494 virtual void visit(DeclarationExp *e) { visit((Expression *)e); }
495 virtual void visit(TypeidExp *e) { visit((Expression *)e); }
496 virtual void visit(TraitsExp *e) { visit((Expression *)e); }
497 virtual void visit(HaltExp *e) { visit((Expression *)e); }
498 virtual void visit(IsExp *e) { visit((Expression *)e); }
499 virtual void visit(UnaExp *e) { visit((Expression *)e); }
500 virtual void visit(BinExp *e) { visit((Expression *)e); }
501 virtual void visit(BinAssignExp *e) { visit((BinExp *)e); }
502 virtual void visit(CompileExp *e) { visit((UnaExp *)e); }
503 virtual void visit(ImportExp *e) { visit((UnaExp *)e); }
504 virtual void visit(AssertExp *e) { visit((UnaExp *)e); }
505 virtual void visit(DotIdExp *e) { visit((UnaExp *)e); }
506 virtual void visit(DotTemplateExp *e) { visit((UnaExp *)e); }
507 virtual void visit(DotVarExp *e) { visit((UnaExp *)e); }
508 virtual void visit(DotTemplateInstanceExp *e) { visit((UnaExp *)e); }
509 virtual void visit(DelegateExp *e) { visit((UnaExp *)e); }
510 virtual void visit(DotTypeExp *e) { visit((UnaExp *)e); }
511 virtual void visit(CallExp *e) { visit((UnaExp *)e); }
512 virtual void visit(AddrExp *e) { visit((UnaExp *)e); }
513 virtual void visit(PtrExp *e) { visit((UnaExp *)e); }
514 virtual void visit(NegExp *e) { visit((UnaExp *)e); }
515 virtual void visit(UAddExp *e) { visit((UnaExp *)e); }
516 virtual void visit(ComExp *e) { visit((UnaExp *)e); }
517 virtual void visit(NotExp *e) { visit((UnaExp *)e); }
518 virtual void visit(DeleteExp *e) { visit((UnaExp *)e); }
519 virtual void visit(CastExp *e) { visit((UnaExp *)e); }
520 virtual void visit(VectorExp *e) { visit((UnaExp *)e); }
521 virtual void visit(VectorArrayExp *e) { visit((UnaExp *)e); }
522 virtual void visit(SliceExp *e) { visit((UnaExp *)e); }
523 virtual void visit(ArrayLengthExp *e) { visit((UnaExp *)e); }
524 virtual void visit(IntervalExp *e) { visit((Expression *)e); }
525 virtual void visit(DelegatePtrExp *e) { visit((UnaExp *)e); }
526 virtual void visit(DelegateFuncptrExp *e) { visit((UnaExp *)e); }
527 virtual void visit(ArrayExp *e) { visit((UnaExp *)e); }
528 virtual void visit(DotExp *e) { visit((BinExp *)e); }
529 virtual void visit(CommaExp *e) { visit((BinExp *)e); }
530 virtual void visit(IndexExp *e) { visit((BinExp *)e); }
531 virtual void visit(PostExp *e) { visit((BinExp *)e); }
532 virtual void visit(PreExp *e) { visit((UnaExp *)e); }
533 virtual void visit(AssignExp *e) { visit((BinExp *)e); }
534 virtual void visit(ConstructExp *e) { visit((AssignExp *)e); }
535 virtual void visit(BlitExp *e) { visit((AssignExp *)e); }
536 virtual void visit(AddAssignExp *e) { visit((BinAssignExp *)e); }
537 virtual void visit(MinAssignExp *e) { visit((BinAssignExp *)e); }
538 virtual void visit(MulAssignExp *e) { visit((BinAssignExp *)e); }
539 virtual void visit(DivAssignExp *e) { visit((BinAssignExp *)e); }
540 virtual void visit(ModAssignExp *e) { visit((BinAssignExp *)e); }
541 virtual void visit(AndAssignExp *e) { visit((BinAssignExp *)e); }
542 virtual void visit(OrAssignExp *e) { visit((BinAssignExp *)e); }
543 virtual void visit(XorAssignExp *e) { visit((BinAssignExp *)e); }
544 virtual void visit(PowAssignExp *e) { visit((BinAssignExp *)e); }
545 virtual void visit(ShlAssignExp *e) { visit((BinAssignExp *)e); }
546 virtual void visit(ShrAssignExp *e) { visit((BinAssignExp *)e); }
547 virtual void visit(UshrAssignExp *e) { visit((BinAssignExp *)e); }
548 virtual void visit(CatAssignExp *e) { visit((BinAssignExp *)e); }
549 virtual void visit(AddExp *e) { visit((BinExp *)e); }
550 virtual void visit(MinExp *e) { visit((BinExp *)e); }
551 virtual void visit(CatExp *e) { visit((BinExp *)e); }
552 virtual void visit(MulExp *e) { visit((BinExp *)e); }
553 virtual void visit(DivExp *e) { visit((BinExp *)e); }
554 virtual void visit(ModExp *e) { visit((BinExp *)e); }
555 virtual void visit(PowExp *e) { visit((BinExp *)e); }
556 virtual void visit(ShlExp *e) { visit((BinExp *)e); }
557 virtual void visit(ShrExp *e) { visit((BinExp *)e); }
558 virtual void visit(UshrExp *e) { visit((BinExp *)e); }
559 virtual void visit(AndExp *e) { visit((BinExp *)e); }
560 virtual void visit(OrExp *e) { visit((BinExp *)e); }
561 virtual void visit(XorExp *e) { visit((BinExp *)e); }
562 virtual void visit(OrOrExp *e) { visit((BinExp *)e); }
563 virtual void visit(AndAndExp *e) { visit((BinExp *)e); }
564 virtual void visit(CmpExp *e) { visit((BinExp *)e); }
565 virtual void visit(InExp *e) { visit((BinExp *)e); }
566 virtual void visit(RemoveExp *e) { visit((BinExp *)e); }
567 virtual void visit(EqualExp *e) { visit((BinExp *)e); }
568 virtual void visit(IdentityExp *e) { visit((BinExp *)e); }
569 virtual void visit(CondExp *e) { visit((BinExp *)e); }
570 virtual void visit(DefaultInitExp *e) { visit((Expression *)e); }
571 virtual void visit(FileInitExp *e) { visit((DefaultInitExp *)e); }
572 virtual void visit(LineInitExp *e) { visit((DefaultInitExp *)e); }
573 virtual void visit(ModuleInitExp *e) { visit((DefaultInitExp *)e); }
574 virtual void visit(FuncInitExp *e) { visit((DefaultInitExp *)e); }
575 virtual void visit(PrettyFuncInitExp *e) { visit((DefaultInitExp *)e); }
576 virtual void visit(ClassReferenceExp *e) { visit((Expression *)e); }
577 virtual void visit(VoidInitExp *e) { visit((Expression *)e); }
578 virtual void visit(ThrownExceptionExp *e) { visit((Expression *)e); }
579
580 virtual void visit(TemplateParameter *) { assert(0); }
581 virtual void visit(TemplateTypeParameter *tp) { visit((TemplateParameter *)tp); }
582 virtual void visit(TemplateThisParameter *tp) { visit((TemplateTypeParameter *)tp); }
583 virtual void visit(TemplateValueParameter *tp) { visit((TemplateParameter *)tp); }
584 virtual void visit(TemplateAliasParameter *tp) { visit((TemplateParameter *)tp); }
585 virtual void visit(TemplateTupleParameter *tp) { visit((TemplateParameter *)tp); }
586
587 virtual void visit(Condition *) { assert(0); }
588 virtual void visit(DVCondition *c) { visit((Condition *)c); }
589 virtual void visit(DebugCondition *c) { visit((DVCondition *)c); }
590 virtual void visit(VersionCondition *c) { visit((DVCondition *)c); }
591 virtual void visit(StaticIfCondition *c) { visit((Condition *)c); }
592
593 virtual void visit(Parameter *) { assert(0); }
594 };
595
596 class StoppableVisitor : public Visitor
597 {
598 public:
599 bool stop;
600 StoppableVisitor() : stop(false) {}
601 };