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