net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/dom/DefaultASTVisitor.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2007 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpdt.core.dom;
  12 /**
  13  */
  14 class DefaultASTVisitor extends ASTVisitor {
  15         /**
  16          *
  17          */
  18         public DefaultASTVisitor() {
  19                 super();
  20         }
  21
  22         /**
  23          *
  24          */
  25         public DefaultASTVisitor(boolean visitDocTags) {
  26                 super(visitDocTags);
  27         }
  28
  29         public void endVisit(AnnotationTypeDeclaration node) {
  30                 endVisitNode(node);
  31         }
  32
  33         public void endVisit(AnnotationTypeMemberDeclaration node) {
  34                 endVisitNode(node);
  35         }
  36
  37         public void endVisit(AnonymousClassDeclaration node) {
  38                 endVisitNode(node);
  39         }
  40         public void endVisit(ArrayAccess node) {
  41                 endVisitNode(node);
  42         }
  43         public void endVisit(ArrayCreation node) {
  44                 endVisitNode(node);
  45         }
  46         public void endVisit(ArrayInitializer node) {
  47                 endVisitNode(node);
  48         }
  49         public void endVisit(ArrayType node) {
  50                 endVisitNode(node);
  51         }
  52         public void endVisit(AssertStatement node) {
  53                 endVisitNode(node);
  54         }
  55         public void endVisit(Assignment node) {
  56                 endVisitNode(node);
  57         }
  58         public void endVisit(Block node) {
  59                 endVisitNode(node);
  60         }
  61         /* since 3.0 */
  62         public void endVisit(BlockComment node) {
  63                 endVisitNode(node);
  64         }
  65         public void endVisit(BooleanLiteral node) {
  66                 endVisitNode(node);
  67         }
  68         public void endVisit(BreakStatement node) {
  69                 endVisitNode(node);
  70         }
  71         public void endVisit(CastExpression node) {
  72                 endVisitNode(node);
  73         }
  74         public void endVisit(CatchClause node) {
  75                 endVisitNode(node);
  76         }
  77         public void endVisit(CharacterLiteral node) {
  78                 endVisitNode(node);
  79         }
  80         public void endVisit(ClassInstanceCreation node) {
  81                 endVisitNode(node);
  82         }
  83         public void endVisit(CompilationUnit node) {
  84                 endVisitNode(node);
  85         }
  86         public void endVisit(ConditionalExpression node) {
  87                 endVisitNode(node);
  88         }
  89         public void endVisit(ConstructorInvocation node) {
  90                 endVisitNode(node);
  91         }
  92         public void endVisit(ContinueStatement node) {
  93                 endVisitNode(node);
  94         }
  95         public void endVisit(DoStatement node) {
  96                 endVisitNode(node);
  97         }
  98         public void endVisit(EmptyStatement node) {
  99                 endVisitNode(node);
 100         }
 101         public void endVisit(EnhancedForStatement node) {
 102                 endVisitNode(node);
 103         }
 104         public void endVisit(EnumConstantDeclaration node) {
 105                 endVisitNode(node);
 106         }
 107         public void endVisit(EnumDeclaration node) {
 108                 endVisitNode(node);
 109         }
 110         public void endVisit(ExpressionStatement node) {
 111                 endVisitNode(node);
 112         }
 113         public void endVisit(FieldAccess node) {
 114                 endVisitNode(node);
 115         }
 116         public void endVisit(FieldDeclaration node) {
 117                 endVisitNode(node);
 118         }
 119         public void endVisit(ForStatement node) {
 120                 endVisitNode(node);
 121         }
 122         public void endVisit(IfStatement node) {
 123                 endVisitNode(node);
 124         }
 125         public void endVisit(ImportDeclaration node) {
 126                 endVisitNode(node);
 127         }
 128         public void endVisit(InfixExpression node) {
 129                 endVisitNode(node);
 130         }
 131         public void endVisit(Initializer node) {
 132                 endVisitNode(node);
 133         }
 134         public void endVisit(InstanceofExpression node) {
 135                 endVisitNode(node);
 136         }
 137         public void endVisit(Javadoc node) {
 138                 endVisitNode(node);
 139         }
 140         public void endVisit(LabeledStatement node) {
 141                 endVisitNode(node);
 142         }
 143         public void endVisit(LineComment node) {
 144                 endVisitNode(node);
 145         }
 146         public void endVisit(MarkerAnnotation node) {
 147                 endVisitNode(node);
 148         }
 149         public void endVisit(MemberRef node) {
 150                 endVisitNode(node);
 151         }
 152         public void endVisit(MemberValuePair node) {
 153                 endVisitNode(node);
 154         }
 155         public void endVisit(MethodDeclaration node) {
 156                 endVisitNode(node);
 157         }
 158         public void endVisit(MethodInvocation node) {
 159                 endVisitNode(node);
 160         }
 161         public void endVisit(MethodRef node) {
 162                 endVisitNode(node);
 163         }
 164         public void endVisit(MethodRefParameter node) {
 165                 endVisitNode(node);
 166         }
 167         public void endVisit(NormalAnnotation node) {
 168                 endVisitNode(node);
 169         }
 170         public void endVisit(NullLiteral node) {
 171                 endVisitNode(node);
 172         }
 173         public void endVisit(NumberLiteral node) {
 174                 endVisitNode(node);
 175         }
 176         public void endVisit(PackageDeclaration node) {
 177                 endVisitNode(node);
 178         }
 179         public void endVisit(ParameterizedType node) {
 180                 endVisitNode(node);
 181         }
 182         public void endVisit(ParenthesizedExpression node) {
 183                 endVisitNode(node);
 184         }
 185         public void endVisit(PostfixExpression node) {
 186                 endVisitNode(node);
 187         }
 188         public void endVisit(PrefixExpression node) {
 189                 endVisitNode(node);
 190         }
 191         public void endVisit(PrimitiveType node) {
 192                 endVisitNode(node);
 193         }
 194         public void endVisit(QualifiedName node) {
 195                 endVisitNode(node);
 196         }
 197         public void endVisit(QualifiedType node) {
 198                 endVisitNode(node);
 199         }
 200         public void endVisit(ReturnStatement node) {
 201                 endVisitNode(node);
 202         }
 203         public void endVisit(SimpleName node) {
 204                 endVisitNode(node);
 205         }
 206         public void endVisit(SimpleType node) {
 207                 endVisitNode(node);
 208         }
 209         public void endVisit(SingleMemberAnnotation node) {
 210                 endVisitNode(node);
 211         }
 212         public void endVisit(SingleVariableDeclaration node) {
 213                 endVisitNode(node);
 214         }
 215         public void endVisit(StringLiteral node) {
 216                 endVisitNode(node);
 217         }
 218         public void endVisit(SuperConstructorInvocation node) {
 219                 endVisitNode(node);
 220         }
 221         public void endVisit(SuperFieldAccess node) {
 222                 endVisitNode(node);
 223         }
 224         public void endVisit(SuperMethodInvocation node) {
 225                 endVisitNode(node);
 226         }
 227
 228         public void endVisit(SwitchCase node) {
 229                 endVisitNode(node);
 230         }
 231         public void endVisit(SwitchStatement node) {
 232                 endVisitNode(node);
 233         }
 234         public void endVisit(SynchronizedStatement node) {
 235                 endVisitNode(node);
 236         }
 237         public void endVisit(TagElement node) {
 238                 endVisitNode(node);
 239         }
 240         public void endVisit(TextElement node) {
 241                 endVisitNode(node);
 242         }
 243         public void endVisit(ThisExpression node) {
 244                 endVisitNode(node);
 245         }
 246         public void endVisit(ThrowStatement node) {
 247                 endVisitNode(node);
 248         }
 249         public void endVisit(TryStatement node) {
 250                 endVisitNode(node);
 251         }
 252
 253         public void endVisit(TypeDeclaration node) {
 254                 endVisitNode(node);
 255         }
 256         public void endVisit(TypeDeclarationStatement node) {
 257                 endVisitNode(node);
 258         }
 259         public void endVisit(TypeLiteral node) {
 260                 endVisitNode(node);
 261         }
 262         public void endVisit(TypeParameter node) {
 263                 endVisitNode(node);
 264         }
 265         public void endVisit(VariableDeclarationExpression node) {
 266                 endVisitNode(node);
 267         }
 268         public void endVisit(VariableDeclarationFragment node) {
 269                 endVisitNode(node);
 270         }
 271         public void endVisit(VariableDeclarationStatement node) {
 272                 endVisitNode(node);
 273         }
 274         public void endVisit(WhileStatement node) {
 275                 endVisitNode(node);
 276         }
 277         public void endVisit(WildcardType node) {
 278                 endVisitNode(node);
 279         }
 280         protected void endVisitNode(ASTNode node) {
 281                 // do nothing
 282         }
 283         public boolean visit(AnnotationTypeDeclaration node) {
 284                 return visitNode(node);
 285         }
 286         public boolean visit(AnnotationTypeMemberDeclaration node) {
 287                 return visitNode(node);
 288         }
 289         public boolean visit(AnonymousClassDeclaration node) {
 290                 return visitNode(node);
 291         }
 292         public boolean visit(ArrayAccess node) {
 293                 return visitNode(node);
 294         }
 295         public boolean visit(ArrayCreation node) {
 296                 return visitNode(node);
 297         }
 298         public boolean visit(ArrayInitializer node) {
 299                 return visitNode(node);
 300         }
 301         public boolean visit(ArrayType node) {
 302                 visitNode(node);
 303                 return false;
 304         }
 305         public boolean visit(AssertStatement node) {
 306                 return visitNode(node);
 307         }
 308         public boolean visit(Assignment node) {
 309                 return visitNode(node);
 310         }
 311         public boolean visit(Block node) {
 312                 return visitNode(node);
 313         }
 314         /* since 3.0 */
 315         public boolean visit(BlockComment node) {
 316                 return visitNode(node);
 317         }
 318         public boolean visit(BooleanLiteral node) {
 319                 return visitNode(node);
 320         }
 321         public boolean visit(BreakStatement node) {
 322                 return visitNode(node);
 323         }
 324         public boolean visit(CastExpression node) {
 325                 return visitNode(node);
 326         }
 327         public boolean visit(CatchClause node) {
 328                 return visitNode(node);
 329         }
 330         public boolean visit(CharacterLiteral node) {
 331                 return visitNode(node);
 332         }
 333         public boolean visit(ClassInstanceCreation node) {
 334                 return visitNode(node);
 335         }
 336         public boolean visit(CompilationUnit node) {
 337                 return visitNode(node);
 338         }
 339         public boolean visit(ConditionalExpression node) {
 340                 return visitNode(node);
 341         }
 342         public boolean visit(ConstructorInvocation node) {
 343                 return visitNode(node);
 344         }
 345         public boolean visit(ContinueStatement node) {
 346                 return visitNode(node);
 347         }
 348         public boolean visit(DoStatement node) {
 349                 return visitNode(node);
 350         }
 351         public boolean visit(EmptyStatement node) {
 352                 return visitNode(node);
 353         }
 354         public boolean visit(EnhancedForStatement node) {
 355                 return visitNode(node);
 356         }
 357         public boolean visit(EnumConstantDeclaration node) {
 358                 return visitNode(node);
 359         }
 360         public boolean visit(EnumDeclaration node) {
 361                 return visitNode(node);
 362         }
 363         public boolean visit(ExpressionStatement node) {
 364                 return visitNode(node);
 365         }
 366         public boolean visit(FieldAccess node) {
 367                 return visitNode(node);
 368         }
 369         public boolean visit(FieldDeclaration node) {
 370                 return visitNode(node);
 371         }
 372         public boolean visit(ForStatement node) {
 373                 return visitNode(node);
 374         }
 375         public boolean visit(IfStatement node) {
 376                 return visitNode(node);
 377         }
 378         public boolean visit(ImportDeclaration node) {
 379                 return visitNode(node);
 380         }
 381         public boolean visit(InfixExpression node) {
 382                 return visitNode(node);
 383         }
 384         public boolean visit(Initializer node) {
 385                 return visitNode(node);
 386         }
 387         public boolean visit(InstanceofExpression node) {
 388                 return visitNode(node);
 389         }
 390         public boolean visit(Javadoc node) {
 391                 //      do not visit Javadoc tags by default. Use constructor with boolean to enable.
 392                 if (super.visit(node)) {
 393                         return visitNode(node);
 394                 }
 395                 return false;
 396         }
 397         public boolean visit(LabeledStatement node) {
 398                 return visitNode(node);
 399         }
 400         public boolean visit(LineComment node) {
 401                 return visitNode(node);
 402         }
 403         public boolean visit(MarkerAnnotation node) {
 404                 return visitNode(node);
 405         }
 406         public boolean visit(MemberRef node) {
 407                 return visitNode(node);
 408         }
 409         public boolean visit(MemberValuePair node) {
 410                 return visitNode(node);
 411         }
 412         public boolean visit(MethodDeclaration node) {
 413                 return visitNode(node);
 414         }
 415         public boolean visit(MethodInvocation node) {
 416                 return visitNode(node);
 417         }
 418         public boolean visit(MethodRef node) {
 419                 return visitNode(node);
 420         }
 421         public boolean visit(MethodRefParameter node) {
 422                 return visitNode(node);
 423         }
 424         public boolean visit(NormalAnnotation node) {
 425                 return visitNode(node);
 426         }
 427         public boolean visit(NullLiteral node) {
 428                 return visitNode(node);
 429         }
 430         public boolean visit(NumberLiteral node) {
 431                 return visitNode(node);
 432         }
 433         public boolean visit(PackageDeclaration node) {
 434                 return visitNode(node);
 435         }
 436         public boolean visit(ParameterizedType node) {
 437                 return visitNode(node);
 438         }
 439         public boolean visit(ParenthesizedExpression node) {
 440                 return visitNode(node);
 441         }
 442         public boolean visit(PostfixExpression node) {
 443                 return visitNode(node);
 444         }
 445         public boolean visit(PrefixExpression node) {
 446                 return visitNode(node);
 447         }
 448
 449         public boolean visit(PrimitiveType node) {
 450                 return visitNode(node);
 451         }
 452         public boolean visit(QualifiedName node) {
 453                 return visitNode(node);
 454         }
 455         public boolean visit(QualifiedType node) {
 456                 return visitNode(node);
 457         }
 458         public boolean visit(ReturnStatement node) {
 459                 return visitNode(node);
 460         }
 461         public boolean visit(SimpleName node) {
 462                 return visitNode(node);
 463         }
 464         public boolean visit(SimpleType node) {
 465                 return visitNode(node);
 466         }
 467         public boolean visit(SingleMemberAnnotation node) {
 468                 return visitNode(node);
 469         }
 470         public boolean visit(SingleVariableDeclaration node) {
 471                 return visitNode(node);
 472         }
 473
 474         public boolean visit(StringLiteral node) {
 475                 return visitNode(node);
 476         }
 477
 478         public boolean visit(SuperConstructorInvocation node) {
 479                 return visitNode(node);
 480         }
 481
 482         public boolean visit(SuperFieldAccess node) {
 483                 return visitNode(node);
 484         }
 485
 486         public boolean visit(SuperMethodInvocation node) {
 487                 return visitNode(node);
 488         }
 489
 490         public boolean visit(SwitchCase node) {
 491                 return visitNode(node);
 492         }
 493
 494         public boolean visit(SwitchStatement node) {
 495                 return visitNode(node);
 496         }
 497
 498         public boolean visit(SynchronizedStatement node) {
 499                 return visitNode(node);
 500         }
 501
 502         public boolean visit(TagElement node) {
 503                 return visitNode(node);
 504         }
 505
 506         public boolean visit(TextElement node) {
 507                 return visitNode(node);
 508         }
 509
 510         public boolean visit(ThisExpression node) {
 511                 return visitNode(node);
 512         }
 513
 514         public boolean visit(ThrowStatement node) {
 515                 return visitNode(node);
 516         }
 517
 518         public boolean visit(TryStatement node) {
 519                 return visitNode(node);
 520         }
 521
 522         public boolean visit(TypeDeclaration node) {
 523                 return visitNode(node);
 524         }
 525
 526         public boolean visit(TypeDeclarationStatement node) {
 527                 return visitNode(node);
 528         }
 529
 530         public boolean visit(TypeLiteral node) {
 531                 return visitNode(node);
 532         }
 533
 534         public boolean visit(TypeParameter node) {
 535                 return visitNode(node);
 536         }
 537
 538         public boolean visit(VariableDeclarationExpression node) {
 539                 return visitNode(node);
 540         }
 541
 542         public boolean visit(VariableDeclarationFragment node) {
 543                 return visitNode(node);
 544         }
 545
 546         public boolean visit(VariableDeclarationStatement node) {
 547                 return visitNode(node);
 548         }
 549
 550         public boolean visit(WhileStatement node) {
 551                 return visitNode(node);
 552         }
 553
 554         public boolean visit(WildcardType node) {
 555                 return visitNode(node);
 556         }
 557
 558         protected boolean visitNode(ASTNode node) {
 559                 return true;
 560         }
 561
 562 }