ReversedDepthFirstAdapter.java Source File

00001 package edu.ksu.cis.bandera.jjjc.analysis;
00002 
00003 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
00004  * Bandera, a Java(TM) analysis and transformation toolkit           *
00005  * Copyright (C) 1998-2001 SAnToS Laboratories (santos@cis.ksu.edu)  *
00006 
00007  * All rights reserved.                                              *
00008  *                                                                   *
00009  * This work was done as a project in the SAnToS Laboratory,         *
00010  * Department of Computing and Information Sciences, Kansas State    *
00011  * University, USA (http://www.cis.ksu.edu/santos).                  *
00012  * It is understood that any modification not identified as such is  *
00013  * not covered by the preceding statement.                           *
00014  *                                                                   *
00015  * This work is free software; you can redistribute it and/or        *
00016  * modify it under the terms of the GNU Library General Public       *
00017  * License as published by the Free Software Foundation; either      *
00018  * version 2 of the License, or (at your option) any later version.  *
00019  *                                                                   *
00020  * This work is distributed in the hope that it will be useful,      *
00021  * but WITHOUT ANY WARRANTY; without even the implied warranty of    *
00022  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU *
00023  * Library General Public License for more details.                  *
00024  *                                                                   *
00025  * You should have received a copy of the GNU Library General Public *
00026  * License along with this toolkit; if not, write to the             *
00027  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,      *
00028  * Boston, MA  02111-1307, USA.                                      *
00029  *                                                                   *
00030  * Java is a trademark of Sun Microsystems, Inc.                     *
00031  *                                                                   *
00032  * To submit a bug report, send a comment, or get the latest news on *
00033  * this project and other SAnToS projects, please visit the web-site *
00034  *                http://www.cis.ksu.edu/santos                      *
00035  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
00036 import ca.mcgill.sable.util.*;
00037 import edu.ksu.cis.bandera.jjjc.node.*;
00038 
00039 public class ReversedDepthFirstAdapter extends AnalysisAdapter
00040 {
00041     public void caseAAbstractMethodDeclaration(AAbstractMethodDeclaration node)
00042     {
00043         inAAbstractMethodDeclaration(node);
00044         if(node.getSemicolon() != null)
00045         {
00046             node.getSemicolon().apply(this);
00047         }
00048         if(node.getMethodHeader() != null)
00049         {
00050             node.getMethodHeader().apply(this);
00051         }
00052         outAAbstractMethodDeclaration(node);
00053     }
00054     public void caseAAbstractMethodDeclarationInterfaceMemberDeclaration(AAbstractMethodDeclarationInterfaceMemberDeclaration node)
00055     {
00056         inAAbstractMethodDeclarationInterfaceMemberDeclaration(node);
00057         if(node.getSemicolon() != null)
00058         {
00059             node.getSemicolon().apply(this);
00060         }
00061         if(node.getMethodHeader() != null)
00062         {
00063             node.getMethodHeader().apply(this);
00064         }
00065         outAAbstractMethodDeclarationInterfaceMemberDeclaration(node);
00066     }
00067     public void caseAAbstractModifier(AAbstractModifier node)
00068     {
00069         inAAbstractModifier(node);
00070         if(node.getAbstract() != null)
00071         {
00072             node.getAbstract().apply(this);
00073         }
00074         outAAbstractModifier(node);
00075     }
00076     public void caseAAdditiveExpShiftExp(AAdditiveExpShiftExp node)
00077     {
00078         inAAdditiveExpShiftExp(node);
00079         if(node.getAdditiveExp() != null)
00080         {
00081             node.getAdditiveExp().apply(this);
00082         }
00083         outAAdditiveExpShiftExp(node);
00084     }
00085     public void caseAAndBinaryOperator(AAndBinaryOperator node)
00086     {
00087         inAAndBinaryOperator(node);
00088         if(node.getAnd() != null)
00089         {
00090             node.getAnd().apply(this);
00091         }
00092         outAAndBinaryOperator(node);
00093     }
00094     public void caseAAndExpAndExp(AAndExpAndExp node)
00095     {
00096         inAAndExpAndExp(node);
00097         if(node.getEqualityExp() != null)
00098         {
00099             node.getEqualityExp().apply(this);
00100         }
00101         if(node.getBitAnd() != null)
00102         {
00103             node.getBitAnd().apply(this);
00104         }
00105         if(node.getAndExp() != null)
00106         {
00107             node.getAndExp().apply(this);
00108         }
00109         outAAndExpAndExp(node);
00110     }
00111     public void caseAAndExpExclusiveOrExp(AAndExpExclusiveOrExp node)
00112     {
00113         inAAndExpExclusiveOrExp(node);
00114         if(node.getAndExp() != null)
00115         {
00116             node.getAndExp().apply(this);
00117         }
00118         outAAndExpExclusiveOrExp(node);
00119     }
00120     public void caseAArgumentListArgumentList(AArgumentListArgumentList node)
00121     {
00122         inAArgumentListArgumentList(node);
00123         if(node.getExp() != null)
00124         {
00125             node.getExp().apply(this);
00126         }
00127         if(node.getComma() != null)
00128         {
00129             node.getComma().apply(this);
00130         }
00131         if(node.getArgumentList() != null)
00132         {
00133             node.getArgumentList().apply(this);
00134         }
00135         outAArgumentListArgumentList(node);
00136     }
00137     public void caseAArrayAccessExp(AArrayAccessExp node)
00138     {
00139         inAArrayAccessExp(node);
00140         if(node.getArrayAccess() != null)
00141         {
00142             node.getArrayAccess().apply(this);
00143         }
00144         outAArrayAccessExp(node);
00145     }
00146     public void caseAArrayAccessLeftHandSide(AArrayAccessLeftHandSide node)
00147     {
00148         inAArrayAccessLeftHandSide(node);
00149         if(node.getArrayAccess() != null)
00150         {
00151             node.getArrayAccess().apply(this);
00152         }
00153         outAArrayAccessLeftHandSide(node);
00154     }
00155     public void caseAArrayAccessPrimaryNoNewArray(AArrayAccessPrimaryNoNewArray node)
00156     {
00157         inAArrayAccessPrimaryNoNewArray(node);
00158         if(node.getArrayAccess() != null)
00159         {
00160             node.getArrayAccess().apply(this);
00161         }
00162         outAArrayAccessPrimaryNoNewArray(node);
00163     }
00164     public void caseAArrayCreationExpPrimary(AArrayCreationExpPrimary node)
00165     {
00166         inAArrayCreationExpPrimary(node);
00167         if(node.getArrayCreationExp() != null)
00168         {
00169             node.getArrayCreationExp().apply(this);
00170         }
00171         outAArrayCreationExpPrimary(node);
00172     }
00173     public void caseAArrayInitializer(AArrayInitializer node)
00174     {
00175         inAArrayInitializer(node);
00176         if(node.getRBrace() != null)
00177         {
00178             node.getRBrace().apply(this);
00179         }
00180         if(node.getComma() != null)
00181         {
00182             node.getComma().apply(this);
00183         }
00184         {
00185             Object temp[] = node.getVariableInitializer().toArray();
00186             for(int i = temp.length - 1; i >= 0; i--)
00187             {
00188                 ((PVariableInitializer) temp[i]).apply(this);
00189             }
00190         }
00191         if(node.getLBrace() != null)
00192         {
00193             node.getLBrace().apply(this);
00194         }
00195         outAArrayInitializer(node);
00196     }
00197     public void caseAArrayReferenceType(AArrayReferenceType node)
00198     {
00199         inAArrayReferenceType(node);
00200         if(node.getArrayType() != null)
00201         {
00202             node.getArrayType().apply(this);
00203         }
00204         outAArrayReferenceType(node);
00205     }
00206     public void caseAArrayVariableInitializer(AArrayVariableInitializer node)
00207     {
00208         inAArrayVariableInitializer(node);
00209         if(node.getArrayInitializer() != null)
00210         {
00211             node.getArrayInitializer().apply(this);
00212         }
00213         outAArrayVariableInitializer(node);
00214     }
00215     public void caseAAssertionCompilationUnit(AAssertionCompilationUnit node)
00216     {
00217         inAAssertionCompilationUnit(node);
00218         if(node.getExp() != null)
00219         {
00220             node.getExp().apply(this);
00221         }
00222         outAAssertionCompilationUnit(node);
00223     }
00224     public void caseAAssignAssignmentOperator(AAssignAssignmentOperator node)
00225     {
00226         inAAssignAssignmentOperator(node);
00227         if(node.getAssign() != null)
00228         {
00229             node.getAssign().apply(this);
00230         }
00231         outAAssignAssignmentOperator(node);
00232     }
00233     public void caseAAssignedVariableDeclarator(AAssignedVariableDeclarator node)
00234     {
00235         inAAssignedVariableDeclarator(node);
00236         if(node.getVariableInitializer() != null)
00237         {
00238             node.getVariableInitializer().apply(this);
00239         }
00240         if(node.getAssign() != null)
00241         {
00242             node.getAssign().apply(this);
00243         }
00244         if(node.getVariableDeclaratorId() != null)
00245         {
00246             node.getVariableDeclaratorId().apply(this);
00247         }
00248         outAAssignedVariableDeclarator(node);
00249     }
00250     public void caseAAssignment(AAssignment node)
00251     {
00252         inAAssignment(node);
00253         if(node.getAssignmentExp() != null)
00254         {
00255             node.getAssignmentExp().apply(this);
00256         }
00257         if(node.getAssignmentOperator() != null)
00258         {
00259             node.getAssignmentOperator().apply(this);
00260         }
00261         if(node.getLeftHandSide() != null)
00262         {
00263             node.getLeftHandSide().apply(this);
00264         }
00265         outAAssignment(node);
00266     }
00267     public void caseAAssignmentAssignmentExp(AAssignmentAssignmentExp node)
00268     {
00269         inAAssignmentAssignmentExp(node);
00270         if(node.getAssignment() != null)
00271         {
00272             node.getAssignment().apply(this);
00273         }
00274         outAAssignmentAssignmentExp(node);
00275     }
00276     public void caseAAssignmentExp(AAssignmentExp node)
00277     {
00278         inAAssignmentExp(node);
00279         if(node.getExp() != null)
00280         {
00281             node.getExp().apply(this);
00282         }
00283         if(node.getAssignmentOperator() != null)
00284         {
00285             node.getAssignmentOperator().apply(this);
00286         }
00287         if(node.getLeftHandSide() != null)
00288         {
00289             node.getLeftHandSide().apply(this);
00290         }
00291         outAAssignmentExp(node);
00292     }
00293     public void caseAAssignmentStmtExp(AAssignmentStmtExp node)
00294     {
00295         inAAssignmentStmtExp(node);
00296         if(node.getAssignment() != null)
00297         {
00298             node.getAssignment().apply(this);
00299         }
00300         outAAssignmentStmtExp(node);
00301     }
00302     public void caseABinaryExp(ABinaryExp node)
00303     {
00304         inABinaryExp(node);
00305         if(node.getSecond() != null)
00306         {
00307             node.getSecond().apply(this);
00308         }
00309         if(node.getBinaryOperator() != null)
00310         {
00311             node.getBinaryOperator().apply(this);
00312         }
00313         if(node.getFirst() != null)
00314         {
00315             node.getFirst().apply(this);
00316         }
00317         outABinaryExp(node);
00318     }
00319     public void caseABitAndAssignAssignmentOperator(ABitAndAssignAssignmentOperator node)
00320     {
00321         inABitAndAssignAssignmentOperator(node);
00322         if(node.getBitAndAssign() != null)
00323         {
00324             node.getBitAndAssign().apply(this);
00325         }
00326         outABitAndAssignAssignmentOperator(node);
00327     }
00328     public void caseABitAndBinaryOperator(ABitAndBinaryOperator node)
00329     {
00330         inABitAndBinaryOperator(node);
00331         if(node.getBitAnd() != null)
00332         {
00333             node.getBitAnd().apply(this);
00334         }
00335         outABitAndBinaryOperator(node);
00336     }
00337     public void caseABitComplementUnaryExpNotPlusMinus(ABitComplementUnaryExpNotPlusMinus node)
00338     {
00339         inABitComplementUnaryExpNotPlusMinus(node);
00340         if(node.getUnaryExp() != null)
00341         {
00342             node.getUnaryExp().apply(this);
00343         }
00344         if(node.getBitComplement() != null)
00345         {
00346             node.getBitComplement().apply(this);
00347         }
00348         outABitComplementUnaryExpNotPlusMinus(node);
00349     }
00350     public void caseABitComplementUnaryOperator(ABitComplementUnaryOperator node)
00351     {
00352         inABitComplementUnaryOperator(node);
00353         if(node.getBitComplement() != null)
00354         {
00355             node.getBitComplement().apply(this);
00356         }
00357         outABitComplementUnaryOperator(node);
00358     }
00359     public void caseABitOrAssignAssignmentOperator(ABitOrAssignAssignmentOperator node)
00360     {
00361         inABitOrAssignAssignmentOperator(node);
00362         if(node.getBitOrAssign() != null)
00363         {
00364             node.getBitOrAssign().apply(this);
00365         }
00366         outABitOrAssignAssignmentOperator(node);
00367     }
00368     public void caseABitOrBinaryOperator(ABitOrBinaryOperator node)
00369     {
00370         inABitOrBinaryOperator(node);
00371         if(node.getBitOr() != null)
00372         {
00373             node.getBitOr().apply(this);
00374         }
00375         outABitOrBinaryOperator(node);
00376     }
00377     public void caseABitXorAssignAssignmentOperator(ABitXorAssignAssignmentOperator node)
00378     {
00379         inABitXorAssignAssignmentOperator(node);
00380         if(node.getBitXorAssign() != null)
00381         {
00382             node.getBitXorAssign().apply(this);
00383         }
00384         outABitXorAssignAssignmentOperator(node);
00385     }
00386     public void caseABitXorBinaryOperator(ABitXorBinaryOperator node)
00387     {
00388         inABitXorBinaryOperator(node);
00389         if(node.getBitXor() != null)
00390         {
00391             node.getBitXor().apply(this);
00392         }
00393         outABitXorBinaryOperator(node);
00394     }
00395     public void caseABlock(ABlock node)
00396     {
00397         inABlock(node);
00398         if(node.getRBrace() != null)
00399         {
00400             node.getRBrace().apply(this);
00401         }
00402         {
00403             Object temp[] = node.getBlockedStmt().toArray();
00404             for(int i = temp.length - 1; i >= 0; i--)
00405             {
00406                 ((PBlockedStmt) temp[i]).apply(this);
00407             }
00408         }
00409         if(node.getLBrace() != null)
00410         {
00411             node.getLBrace().apply(this);
00412         }
00413         outABlock(node);
00414     }
00415     public void caseABlockClassBodyDeclaration(ABlockClassBodyDeclaration node)
00416     {
00417         inABlockClassBodyDeclaration(node);
00418         if(node.getBlock() != null)
00419         {
00420             node.getBlock().apply(this);
00421         }
00422         outABlockClassBodyDeclaration(node);
00423     }
00424     public void caseABlockMethodBody(ABlockMethodBody node)
00425     {
00426         inABlockMethodBody(node);
00427         if(node.getBlock() != null)
00428         {
00429             node.getBlock().apply(this);
00430         }
00431         outABlockMethodBody(node);
00432     }
00433     public void caseABlockStmt(ABlockStmt node)
00434     {
00435         inABlockStmt(node);
00436         if(node.getBlock() != null)
00437         {
00438             node.getBlock().apply(this);
00439         }
00440         outABlockStmt(node);
00441     }
00442     public void caseABlockStmtWithoutTrailingSubstmt(ABlockStmtWithoutTrailingSubstmt node)
00443     {
00444         inABlockStmtWithoutTrailingSubstmt(node);
00445         if(node.getBlock() != null)
00446         {
00447             node.getBlock().apply(this);
00448         }
00449         outABlockStmtWithoutTrailingSubstmt(node);
00450     }
00451     public void caseABooleanLiteralLiteral(ABooleanLiteralLiteral node)
00452     {
00453         inABooleanLiteralLiteral(node);
00454         if(node.getBooleanLiteral() != null)
00455         {
00456             node.getBooleanLiteral().apply(this);
00457         }
00458         outABooleanLiteralLiteral(node);
00459     }
00460     public void caseABooleanPrimitiveType(ABooleanPrimitiveType node)
00461     {
00462         inABooleanPrimitiveType(node);
00463         if(node.getBoolean() != null)
00464         {
00465             node.getBoolean().apply(this);
00466         }
00467         outABooleanPrimitiveType(node);
00468     }
00469     public void caseABreakStmt(ABreakStmt node)
00470     {
00471         inABreakStmt(node);
00472         if(node.getSemicolon() != null)
00473         {
00474             node.getSemicolon().apply(this);
00475         }
00476         if(node.getId() != null)
00477         {
00478             node.getId().apply(this);
00479         }
00480         if(node.getBreak() != null)
00481         {
00482             node.getBreak().apply(this);
00483         }
00484         outABreakStmt(node);
00485     }
00486     public void caseABreakStmtStmtWithoutTrailingSubstmt(ABreakStmtStmtWithoutTrailingSubstmt node)
00487     {
00488         inABreakStmtStmtWithoutTrailingSubstmt(node);
00489         if(node.getOneBreakStmt() != null)
00490         {
00491             node.getOneBreakStmt().apply(this);
00492         }
00493         outABreakStmtStmtWithoutTrailingSubstmt(node);
00494     }
00495     public void caseAByteIntegralType(AByteIntegralType node)
00496     {
00497         inAByteIntegralType(node);
00498         if(node.getByte() != null)
00499         {
00500             node.getByte().apply(this);
00501         }
00502         outAByteIntegralType(node);
00503     }
00504     public void caseABytePrimitiveType(ABytePrimitiveType node)
00505     {
00506         inABytePrimitiveType(node);
00507         if(node.getByte() != null)
00508         {
00509             node.getByte().apply(this);
00510         }
00511         outABytePrimitiveType(node);
00512     }
00513     public void caseACaseSwitchLabel(ACaseSwitchLabel node)
00514     {
00515         inACaseSwitchLabel(node);
00516         if(node.getColon() != null)
00517         {
00518             node.getColon().apply(this);
00519         }
00520         if(node.getExp() != null)
00521         {
00522             node.getExp().apply(this);
00523         }
00524         if(node.getCase() != null)
00525         {
00526             node.getCase().apply(this);
00527         }
00528         outACaseSwitchLabel(node);
00529     }
00530     public void caseACastExpUnaryExpNotPlusMinus(ACastExpUnaryExpNotPlusMinus node)
00531     {
00532         inACastExpUnaryExpNotPlusMinus(node);
00533         if(node.getCastExp() != null)
00534         {
00535             node.getCastExp().apply(this);
00536         }
00537         outACastExpUnaryExpNotPlusMinus(node);
00538     }
00539     public void caseACatchClause(ACatchClause node)
00540     {
00541         inACatchClause(node);
00542         if(node.getBlock() != null)
00543         {
00544             node.getBlock().apply(this);
00545         }
00546         if(node.getRPar() != null)
00547         {
00548             node.getRPar().apply(this);
00549         }
00550         if(node.getFormalParameter() != null)
00551         {
00552             node.getFormalParameter().apply(this);
00553         }
00554         if(node.getLPar() != null)
00555         {
00556             node.getLPar().apply(this);
00557         }
00558         if(node.getCatch() != null)
00559         {
00560             node.getCatch().apply(this);
00561         }
00562         outACatchClause(node);
00563     }
00564     public void caseACharacterLiteralLiteral(ACharacterLiteralLiteral node)
00565     {
00566         inACharacterLiteralLiteral(node);
00567         if(node.getCharacterLiteral() != null)
00568         {
00569             node.getCharacterLiteral().apply(this);
00570         }
00571         outACharacterLiteralLiteral(node);
00572     }
00573     public void caseACharIntegralType(ACharIntegralType node)
00574     {
00575         inACharIntegralType(node);
00576         if(node.getChar() != null)
00577         {
00578             node.getChar().apply(this);
00579         }
00580         outACharIntegralType(node);
00581     }
00582     public void caseACharPrimitiveType(ACharPrimitiveType node)
00583     {
00584         inACharPrimitiveType(node);
00585         if(node.getChar() != null)
00586         {
00587             node.getChar().apply(this);
00588         }
00589         outACharPrimitiveType(node);
00590     }
00591     public void caseAClassBody(AClassBody node)
00592     {
00593         inAClassBody(node);
00594         if(node.getRBrace() != null)
00595         {
00596             node.getRBrace().apply(this);
00597         }
00598         {
00599             Object temp[] = node.getClassBodyDeclaration().toArray();
00600             for(int i = temp.length - 1; i >= 0; i--)
00601             {
00602                 ((PClassBodyDeclaration) temp[i]).apply(this);
00603             }
00604         }
00605         if(node.getLBrace() != null)
00606         {
00607             node.getLBrace().apply(this);
00608         }
00609         outAClassBody(node);
00610     }
00611     public void caseAClassClassBodyDeclaration(AClassClassBodyDeclaration node)
00612     {
00613         inAClassClassBodyDeclaration(node);
00614         if(node.getClassDeclaration() != null)
00615         {
00616             node.getClassDeclaration().apply(this);
00617         }
00618         outAClassClassBodyDeclaration(node);
00619     }
00620     public void caseAClassDeclaration(AClassDeclaration node)
00621     {
00622         inAClassDeclaration(node);
00623         if(node.getClassBody() != null)
00624         {
00625             node.getClassBody().apply(this);
00626         }
00627         if(node.getInterfaces() != null)
00628         {
00629             node.getInterfaces().apply(this);
00630         }
00631         if(node.getSuper() != null)
00632         {
00633             node.getSuper().apply(this);
00634         }
00635         if(node.getId() != null)
00636         {
00637             node.getId().apply(this);
00638         }
00639         if(node.getTClass() != null)
00640         {
00641             node.getTClass().apply(this);
00642         }
00643         {
00644             Object temp[] = node.getModifier().toArray();
00645             for(int i = temp.length - 1; i >= 0; i--)
00646             {
00647                 ((PModifier) temp[i]).apply(this);
00648             }
00649         }
00650         outAClassDeclaration(node);
00651     }
00652     public void caseAClassDeclarationBlockedStmt(AClassDeclarationBlockedStmt node)
00653     {
00654         inAClassDeclarationBlockedStmt(node);
00655         if(node.getClassDeclaration() != null)
00656         {
00657             node.getClassDeclaration().apply(this);
00658         }
00659         outAClassDeclarationBlockedStmt(node);
00660     }
00661     public void caseAClassDeclarationClassMemberDeclaration(AClassDeclarationClassMemberDeclaration node)
00662     {
00663         inAClassDeclarationClassMemberDeclaration(node);
00664         if(node.getClassDeclaration() != null)
00665         {
00666             node.getClassDeclaration().apply(this);
00667         }
00668         outAClassDeclarationClassMemberDeclaration(node);
00669     }
00670     public void caseAClassDeclarationInterfaceMemberDeclaration(AClassDeclarationInterfaceMemberDeclaration node)
00671     {
00672         inAClassDeclarationInterfaceMemberDeclaration(node);
00673         if(node.getClassDeclaration() != null)
00674         {
00675             node.getClassDeclaration().apply(this);
00676         }
00677         outAClassDeclarationInterfaceMemberDeclaration(node);
00678     }
00679     public void caseAClassInstanceCreationExpPrimaryNoNewArray(AClassInstanceCreationExpPrimaryNoNewArray node)
00680     {
00681         inAClassInstanceCreationExpPrimaryNoNewArray(node);
00682         if(node.getClassInstanceCreationExp() != null)
00683         {
00684             node.getClassInstanceCreationExp().apply(this);
00685         }
00686         outAClassInstanceCreationExpPrimaryNoNewArray(node);
00687     }
00688     public void caseAClassInstanceCreationExpStmtExp(AClassInstanceCreationExpStmtExp node)
00689     {
00690         inAClassInstanceCreationExpStmtExp(node);
00691         if(node.getClassInstanceCreationExp() != null)
00692         {
00693             node.getClassInstanceCreationExp().apply(this);
00694         }
00695         outAClassInstanceCreationExpStmtExp(node);
00696     }
00697     public void caseAClassMemberDeclarationClassBodyDeclaration(AClassMemberDeclarationClassBodyDeclaration node)
00698     {
00699         inAClassMemberDeclarationClassBodyDeclaration(node);
00700         if(node.getClassMemberDeclaration() != null)
00701         {
00702             node.getClassMemberDeclaration().apply(this);
00703         }
00704         outAClassMemberDeclarationClassBodyDeclaration(node);
00705     }
00706     public void caseAClassOrInterfaceType(AClassOrInterfaceType node)
00707     {
00708         inAClassOrInterfaceType(node);
00709         if(node.getName() != null)
00710         {
00711             node.getName().apply(this);
00712         }
00713         outAClassOrInterfaceType(node);
00714     }
00715     public void caseAClassOrInterfaceTypeArrayCreationExp(AClassOrInterfaceTypeArrayCreationExp node)
00716     {
00717         inAClassOrInterfaceTypeArrayCreationExp(node);
00718         {
00719             Object temp[] = node.getDim().toArray();
00720             for(int i = temp.length - 1; i >= 0; i--)
00721             {
00722                 ((PDim) temp[i]).apply(this);
00723             }
00724         }
00725         {
00726             Object temp[] = node.getDimExp().toArray();
00727             for(int i = temp.length - 1; i >= 0; i--)
00728             {
00729                 ((PDimExp) temp[i]).apply(this);
00730             }
00731         }
00732         if(node.getClassOrInterfaceType() != null)
00733         {
00734             node.getClassOrInterfaceType().apply(this);
00735         }
00736         if(node.getNew() != null)
00737         {
00738             node.getNew().apply(this);
00739         }
00740         outAClassOrInterfaceTypeArrayCreationExp(node);
00741     }
00742     public void caseAClassOrInterfaceTypeExp(AClassOrInterfaceTypeExp node)
00743     {
00744         inAClassOrInterfaceTypeExp(node);
00745         {
00746             Object temp[] = node.getDim().toArray();
00747             for(int i = temp.length - 1; i >= 0; i--)
00748             {
00749                 ((PDim) temp[i]).apply(this);
00750             }
00751         }
00752         {
00753             Object temp[] = node.getDimExp().toArray();
00754             for(int i = temp.length - 1; i >= 0; i--)
00755             {
00756                 ((PDimExp) temp[i]).apply(this);
00757             }
00758         }
00759         if(node.getClassOrInterfaceType() != null)
00760         {
00761             node.getClassOrInterfaceType().apply(this);
00762         }
00763         if(node.getNew() != null)
00764         {
00765             node.getNew().apply(this);
00766         }
00767         outAClassOrInterfaceTypeExp(node);
00768     }
00769     public void caseAClassOrInterfaceTypeReferenceType(AClassOrInterfaceTypeReferenceType node)
00770     {
00771         inAClassOrInterfaceTypeReferenceType(node);
00772         if(node.getClassOrInterfaceType() != null)
00773         {
00774             node.getClassOrInterfaceType().apply(this);
00775         }
00776         outAClassOrInterfaceTypeReferenceType(node);
00777     }
00778     public void caseAClassType(AClassType node)
00779     {
00780         inAClassType(node);
00781         if(node.getClassOrInterfaceType() != null)
00782         {
00783             node.getClassOrInterfaceType().apply(this);
00784         }
00785         outAClassType(node);
00786     }
00787     public void caseAClassTypeClassTypeList(AClassTypeClassTypeList node)
00788     {
00789         inAClassTypeClassTypeList(node);
00790         if(node.getClassType() != null)
00791         {
00792             node.getClassType().apply(this);
00793         }
00794         outAClassTypeClassTypeList(node);
00795     }
00796     public void caseAClassTypeDeclaration(AClassTypeDeclaration node)
00797     {
00798         inAClassTypeDeclaration(node);
00799         if(node.getClassDeclaration() != null)
00800         {
00801             node.getClassDeclaration().apply(this);
00802         }
00803         outAClassTypeDeclaration(node);
00804     }
00805     public void caseAClassTypeListClassTypeList(AClassTypeListClassTypeList node)
00806     {
00807         inAClassTypeListClassTypeList(node);
00808         if(node.getClassType() != null)
00809         {
00810             node.getClassType().apply(this);
00811         }
00812         if(node.getComma() != null)
00813         {
00814             node.getComma().apply(this);
00815         }
00816         if(node.getClassTypeList() != null)
00817         {
00818             node.getClassTypeList().apply(this);
00819         }
00820         outAClassTypeListClassTypeList(node);
00821     }
00822     public void caseACompilationUnit(ACompilationUnit node)
00823     {
00824         inACompilationUnit(node);
00825         {
00826             Object temp[] = node.getTypeDeclaration().toArray();
00827             for(int i = temp.length - 1; i >= 0; i--)
00828             {
00829                 ((PTypeDeclaration) temp[i]).apply(this);
00830             }
00831         }
00832         {
00833             Object temp[] = node.getImportDeclaration().toArray();
00834             for(int i = temp.length - 1; i >= 0; i--)
00835             {
00836                 ((PImportDeclaration) temp[i]).apply(this);
00837             }
00838         }
00839         if(node.getSemicolon() != null)
00840         {
00841             node.getSemicolon().apply(this);
00842         }
00843         if(node.getPackageDeclaration() != null)
00844         {
00845             node.getPackageDeclaration().apply(this);
00846         }
00847         if(node.getPackage() != null)
00848         {
00849             node.getPackage().apply(this);
00850         }
00851         outACompilationUnit(node);
00852     }
00853     public void caseAComplementUnaryExpNotPlusMinus(AComplementUnaryExpNotPlusMinus node)
00854     {
00855         inAComplementUnaryExpNotPlusMinus(node);
00856         if(node.getUnaryExp() != null)
00857         {
00858             node.getUnaryExp().apply(this);
00859         }
00860         if(node.getComplement() != null)
00861         {
00862             node.getComplement().apply(this);
00863         }
00864         outAComplementUnaryExpNotPlusMinus(node);
00865     }
00866     public void caseAComplementUnaryOperator(AComplementUnaryOperator node)
00867     {
00868         inAComplementUnaryOperator(node);
00869         if(node.getComplement() != null)
00870         {
00871             node.getComplement().apply(this);
00872         }
00873         outAComplementUnaryOperator(node);
00874     }
00875     public void caseAConditionalAndExpConditionalAndExp(AConditionalAndExpConditionalAndExp node)
00876     {
00877         inAConditionalAndExpConditionalAndExp(node);
00878         if(node.getInclusiveOrExp() != null)
00879         {
00880             node.getInclusiveOrExp().apply(this);
00881         }
00882         if(node.getAnd() != null)
00883         {
00884             node.getAnd().apply(this);
00885         }
00886         if(node.getConditionalAndExp() != null)
00887         {
00888             node.getConditionalAndExp().apply(this);
00889         }
00890         outAConditionalAndExpConditionalAndExp(node);
00891     }
00892     public void caseAConditionalAndExpConditionalOrExp(AConditionalAndExpConditionalOrExp node)
00893     {
00894         inAConditionalAndExpConditionalOrExp(node);
00895         if(node.getConditionalAndExp() != null)
00896         {
00897             node.getConditionalAndExp().apply(this);
00898         }
00899         outAConditionalAndExpConditionalOrExp(node);
00900     }
00901     public void caseAConditionalExpAssignmentExp(AConditionalExpAssignmentExp node)
00902     {
00903         inAConditionalExpAssignmentExp(node);
00904         if(node.getConditionalExp() != null)
00905         {
00906             node.getConditionalExp().apply(this);
00907         }
00908         outAConditionalExpAssignmentExp(node);
00909     }
00910     public void caseAConditionalOrExpConditionalExp(AConditionalOrExpConditionalExp node)
00911     {
00912         inAConditionalOrExpConditionalExp(node);
00913         if(node.getConditionalOrExp() != null)
00914         {
00915             node.getConditionalOrExp().apply(this);
00916         }
00917         outAConditionalOrExpConditionalExp(node);
00918     }
00919     public void caseAConditionalOrExpConditionalOrExp(AConditionalOrExpConditionalOrExp node)
00920     {
00921         inAConditionalOrExpConditionalOrExp(node);
00922         if(node.getConditionalAndExp() != null)
00923         {
00924             node.getConditionalAndExp().apply(this);
00925         }
00926         if(node.getOr() != null)
00927         {
00928             node.getOr().apply(this);
00929         }
00930         if(node.getConditionalOrExp() != null)
00931         {
00932             node.getConditionalOrExp().apply(this);
00933         }
00934         outAConditionalOrExpConditionalOrExp(node);
00935     }
00936     public void caseAConstantDeclaration(AConstantDeclaration node)
00937     {
00938         inAConstantDeclaration(node);
00939         if(node.getFieldDeclaration() != null)
00940         {
00941             node.getFieldDeclaration().apply(this);
00942         }
00943         outAConstantDeclaration(node);
00944     }
00945     public void caseAConstantDeclarationInterfaceMemberDeclaration(AConstantDeclarationInterfaceMemberDeclaration node)
00946     {
00947         inAConstantDeclarationInterfaceMemberDeclaration(node);
00948         if(node.getFieldDeclaration() != null)
00949         {
00950             node.getFieldDeclaration().apply(this);
00951         }
00952         outAConstantDeclarationInterfaceMemberDeclaration(node);
00953     }
00954     public void caseAConstantExp(AConstantExp node)
00955     {
00956         inAConstantExp(node);
00957         if(node.getExp() != null)
00958         {
00959             node.getExp().apply(this);
00960         }
00961         outAConstantExp(node);
00962     }
00963     public void caseAConstructorBody(AConstructorBody node)
00964     {
00965         inAConstructorBody(node);
00966         if(node.getRBrace() != null)
00967         {
00968             node.getRBrace().apply(this);
00969         }
00970         {
00971             Object temp[] = node.getBlockedStmt().toArray();
00972             for(int i = temp.length - 1; i >= 0; i--)
00973             {
00974                 ((PBlockedStmt) temp[i]).apply(this);
00975             }
00976         }
00977         if(node.getConstructorInvocation() != null)
00978         {
00979             node.getConstructorInvocation().apply(this);
00980         }
00981         if(node.getLBrace() != null)
00982         {
00983             node.getLBrace().apply(this);
00984         }
00985         outAConstructorBody(node);
00986     }
00987     public void caseAConstructorClassBodyDeclaration(AConstructorClassBodyDeclaration node)
00988     {
00989         inAConstructorClassBodyDeclaration(node);
00990         if(node.getConstructorDeclaration() != null)
00991         {
00992             node.getConstructorDeclaration().apply(this);
00993         }
00994         outAConstructorClassBodyDeclaration(node);
00995     }
00996     public void caseAConstructorDeclaration(AConstructorDeclaration node)
00997     {
00998         inAConstructorDeclaration(node);
00999         if(node.getConstructorBody() != null)
01000         {
01001             node.getConstructorBody().apply(this);
01002         }
01003         if(node.getThrows() != null)
01004         {
01005             node.getThrows().apply(this);
01006         }
01007         if(node.getConstructorDeclarator() != null)
01008         {
01009             node.getConstructorDeclarator().apply(this);
01010         }
01011         {
01012             Object temp[] = node.getModifier().toArray();
01013             for(int i = temp.length - 1; i >= 0; i--)
01014             {
01015                 ((PModifier) temp[i]).apply(this);
01016             }
01017         }
01018         outAConstructorDeclaration(node);
01019     }
01020     public void caseAConstructorDeclarator(AConstructorDeclarator node)
01021     {
01022         inAConstructorDeclarator(node);
01023         if(node.getRPar() != null)
01024         {
01025             node.getRPar().apply(this);
01026         }
01027         {
01028             Object temp[] = node.getFormalParameter().toArray();
01029             for(int i = temp.length - 1; i >= 0; i--)
01030             {
01031                 ((PFormalParameter) temp[i]).apply(this);
01032             }
01033         }
01034         if(node.getLPar() != null)
01035         {
01036             node.getLPar().apply(this);
01037         }
01038         if(node.getSimpleName() != null)
01039         {
01040             node.getSimpleName().apply(this);
01041         }
01042         outAConstructorDeclarator(node);
01043     }
01044     public void caseAContinueStmt(AContinueStmt node)
01045     {
01046         inAContinueStmt(node);
01047         if(node.getSemicolon() != null)
01048         {
01049             node.getSemicolon().apply(this);
01050         }
01051         if(node.getId() != null)
01052         {
01053             node.getId().apply(this);
01054         }
01055         if(node.getContinue() != null)
01056         {
01057             node.getContinue().apply(this);
01058         }
01059         outAContinueStmt(node);
01060     }
01061     public void caseAContinueStmtStmtWithoutTrailingSubstmt(AContinueStmtStmtWithoutTrailingSubstmt node)
01062     {
01063         inAContinueStmtStmtWithoutTrailingSubstmt(node);
01064         if(node.getOneContinueStmt() != null)
01065         {
01066             node.getOneContinueStmt().apply(this);
01067         }
01068         outAContinueStmtStmtWithoutTrailingSubstmt(node);
01069     }
01070     public void caseADecimalIntegerLiteral(ADecimalIntegerLiteral node)
01071     {
01072         inADecimalIntegerLiteral(node);
01073         if(node.getDecimalIntegerLiteral() != null)
01074         {
01075             node.getDecimalIntegerLiteral().apply(this);
01076         }
01077         outADecimalIntegerLiteral(node);
01078     }
01079     public void caseADecrementUnaryOperator(ADecrementUnaryOperator node)
01080     {
01081         inADecrementUnaryOperator(node);
01082         if(node.getMinusMinus() != null)
01083         {
01084             node.getMinusMinus().apply(this);
01085         }
01086         outADecrementUnaryOperator(node);
01087     }
01088     public void caseADefaultSwitchLabel(ADefaultSwitchLabel node)
01089     {
01090         inADefaultSwitchLabel(node);
01091         if(node.getColon() != null)
01092         {
01093             node.getColon().apply(this);
01094         }
01095         if(node.getDefault() != null)
01096         {
01097             node.getDefault().apply(this);
01098         }
01099         outADefaultSwitchLabel(node);
01100     }
01101     public void caseADim(ADim node)
01102     {
01103         inADim(node);
01104         if(node.getRBracket() != null)
01105         {
01106             node.getRBracket().apply(this);
01107         }
01108         if(node.getLBracket() != null)
01109         {
01110             node.getLBracket().apply(this);
01111         }
01112         outADim(node);
01113     }
01114     public void caseADimExp(ADimExp node)
01115     {
01116         inADimExp(node);
01117         if(node.getRBracket() != null)
01118         {
01119             node.getRBracket().apply(this);
01120         }
01121         if(node.getExp() != null)
01122         {
01123             node.getExp().apply(this);
01124         }
01125         if(node.getLBracket() != null)
01126         {
01127             node.getLBracket().apply(this);
01128         }
01129         outADimExp(node);
01130     }
01131     public void caseADivAssignAssignmentOperator(ADivAssignAssignmentOperator node)
01132     {
01133         inADivAssignAssignmentOperator(node);
01134         if(node.getDivAssign() != null)
01135         {
01136             node.getDivAssign().apply(this);
01137         }
01138         outADivAssignAssignmentOperator(node);
01139     }
01140     public void caseADivBinaryOperator(ADivBinaryOperator node)
01141     {
01142         inADivBinaryOperator(node);
01143         if(node.getDiv() != null)
01144         {
01145             node.getDiv().apply(this);
01146         }
01147         outADivBinaryOperator(node);
01148     }
01149     public void caseADivMultiplicativeExp(ADivMultiplicativeExp node)
01150     {
01151         inADivMultiplicativeExp(node);
01152         if(node.getUnaryExp() != null)
01153         {
01154             node.getUnaryExp().apply(this);
01155         }
01156         if(node.getDiv() != null)
01157         {
01158             node.getDiv().apply(this);
01159         }
01160         if(node.getMultiplicativeExp() != null)
01161         {
01162             node.getMultiplicativeExp().apply(this);
01163         }
01164         outADivMultiplicativeExp(node);
01165     }
01166     public void caseADoStmt(ADoStmt node)
01167     {
01168         inADoStmt(node);
01169         if(node.getSemicolon() != null)
01170         {
01171             node.getSemicolon().apply(this);
01172         }
01173         if(node.getRPar() != null)
01174         {
01175             node.getRPar().apply(this);
01176         }
01177         if(node.getExp() != null)
01178         {
01179             node.getExp().apply(this);
01180         }
01181         if(node.getLPar() != null)
01182         {
01183             node.getLPar().apply(this);
01184         }
01185         if(node.getWhile() != null)
01186         {
01187             node.getWhile().apply(this);
01188         }
01189         if(node.getBlock() != null)
01190         {
01191             node.getBlock().apply(this);
01192         }
01193         if(node.getDo() != null)
01194         {
01195             node.getDo().apply(this);
01196         }
01197         outADoStmt(node);
01198     }
01199     public void caseADoStmtStmtWithoutTrailingSubstmt(ADoStmtStmtWithoutTrailingSubstmt node)
01200     {
01201         inADoStmtStmtWithoutTrailingSubstmt(node);
01202         if(node.getOneDoStmt() != null)
01203         {
01204             node.getOneDoStmt().apply(this);
01205         }
01206         outADoStmtStmtWithoutTrailingSubstmt(node);
01207     }
01208     public void caseADoubleFloatingPointType(ADoubleFloatingPointType node)
01209     {
01210         inADoubleFloatingPointType(node);
01211         if(node.getDouble() != null)
01212         {
01213             node.getDouble().apply(this);
01214         }
01215         outADoubleFloatingPointType(node);
01216     }
01217     public void caseADoublePrimitiveType(ADoublePrimitiveType node)
01218     {
01219         inADoublePrimitiveType(node);
01220         if(node.getDouble() != null)
01221         {
01222             node.getDouble().apply(this);
01223         }
01224         outADoublePrimitiveType(node);
01225     }
01226     public void caseAEmptyMethodBody(AEmptyMethodBody node)
01227     {
01228         inAEmptyMethodBody(node);
01229         if(node.getSemicolon() != null)
01230         {
01231             node.getSemicolon().apply(this);
01232         }
01233         outAEmptyMethodBody(node);
01234     }
01235     public void caseAEmptyStmt(AEmptyStmt node)
01236     {
01237         inAEmptyStmt(node);
01238         if(node.getSemicolon() != null)
01239         {
01240             node.getSemicolon().apply(this);
01241         }
01242         outAEmptyStmt(node);
01243     }
01244     public void caseAEmptyStmtStmtWithoutTrailingSubstmt(AEmptyStmtStmtWithoutTrailingSubstmt node)
01245     {
01246         inAEmptyStmtStmtWithoutTrailingSubstmt(node);
01247         if(node.getSemicolonStmt() != null)
01248         {
01249             node.getSemicolonStmt().apply(this);
01250         }
01251         outAEmptyStmtStmtWithoutTrailingSubstmt(node);
01252     }
01253     public void caseAEmptyTypeDeclaration(AEmptyTypeDeclaration node)
01254     {
01255         inAEmptyTypeDeclaration(node);
01256         if(node.getSemicolon() != null)
01257         {
01258             node.getSemicolon().apply(this);
01259         }
01260         outAEmptyTypeDeclaration(node);
01261     }
01262     public void caseAEqBinaryOperator(AEqBinaryOperator node)
01263     {
01264         inAEqBinaryOperator(node);
01265         if(node.getEq() != null)
01266         {
01267             node.getEq().apply(this);
01268         }
01269         outAEqBinaryOperator(node);
01270     }
01271     public void caseAEqEqualityExp(AEqEqualityExp node)
01272     {
01273         inAEqEqualityExp(node);
01274         if(node.getRelationalExp() != null)
01275         {
01276             node.getRelationalExp().apply(this);
01277         }
01278         if(node.getEq() != null)
01279         {
01280             node.getEq().apply(this);
01281         }
01282         if(node.getEqualityExp() != null)
01283         {
01284             node.getEqualityExp().apply(this);
01285         }
01286         outAEqEqualityExp(node);
01287     }
01288     public void caseAEqualityExpAndExp(AEqualityExpAndExp node)
01289     {
01290         inAEqualityExpAndExp(node);
01291         if(node.getEqualityExp() != null)
01292         {
01293             node.getEqualityExp().apply(this);
01294         }
01295         outAEqualityExpAndExp(node);
01296     }
01297     public void caseAExclusiveOrExpExclusiveOrExp(AExclusiveOrExpExclusiveOrExp node)
01298     {
01299         inAExclusiveOrExpExclusiveOrExp(node);
01300         if(node.getAndExp() != null)
01301         {
01302             node.getAndExp().apply(this);
01303         }
01304         if(node.getBitXor() != null)
01305         {
01306             node.getBitXor().apply(this);
01307         }
01308         if(node.getExclusiveOrExp() != null)
01309         {
01310             node.getExclusiveOrExp().apply(this);
01311         }
01312         outAExclusiveOrExpExclusiveOrExp(node);
01313     }
01314     public void caseAExclusiveOrExpInclusiveOrExp(AExclusiveOrExpInclusiveOrExp node)
01315     {
01316         inAExclusiveOrExpInclusiveOrExp(node);
01317         if(node.getExclusiveOrExp() != null)
01318         {
01319             node.getExclusiveOrExp().apply(this);
01320         }
01321         outAExclusiveOrExpInclusiveOrExp(node);
01322     }
01323     public void caseAExpArgumentList(AExpArgumentList node)
01324     {
01325         inAExpArgumentList(node);
01326         if(node.getExp() != null)
01327         {
01328             node.getExp().apply(this);
01329         }
01330         outAExpArgumentList(node);
01331     }
01332     public void caseAExpCastExp(AExpCastExp node)
01333     {
01334         inAExpCastExp(node);
01335         if(node.getSecond() != null)
01336         {
01337             node.getSecond().apply(this);
01338         }
01339         if(node.getRPar() != null)
01340         {
01341             node.getRPar().apply(this);
01342         }
01343         if(node.getFirst() != null)
01344         {
01345             node.getFirst().apply(this);
01346         }
01347         if(node.getLPar() != null)
01348         {
01349             node.getLPar().apply(this);
01350         }
01351         outAExpCastExp(node);
01352     }
01353     public void caseAExpListForInit(AExpListForInit node)
01354     {
01355         inAExpListForInit(node);
01356         {
01357             Object temp[] = node.getExp().toArray();
01358             for(int i = temp.length - 1; i >= 0; i--)
01359             {
01360                 ((PExp) temp[i]).apply(this);
01361             }
01362         }
01363         outAExpListForInit(node);
01364     }
01365     public void caseAExpStmt(AExpStmt node)
01366     {
01367         inAExpStmt(node);
01368         if(node.getSemicolon() != null)
01369         {
01370             node.getSemicolon().apply(this);
01371         }
01372         if(node.getExp() != null)
01373         {
01374             node.getExp().apply(this);
01375         }
01376         outAExpStmt(node);
01377     }
01378     public void caseAExpStmtStmtWithoutTrailingSubstmt(AExpStmtStmtWithoutTrailingSubstmt node)
01379     {
01380         inAExpStmtStmtWithoutTrailingSubstmt(node);
01381         if(node.getExpStmt() != null)
01382         {
01383             node.getExpStmt().apply(this);
01384         }
01385         outAExpStmtStmtWithoutTrailingSubstmt(node);
01386     }
01387     public void caseAExpVariableInitializer(AExpVariableInitializer node)
01388     {
01389         inAExpVariableInitializer(node);
01390         if(node.getExp() != null)
01391         {
01392             node.getExp().apply(this);
01393         }
01394         outAExpVariableInitializer(node);
01395     }
01396     public void caseAExtendsExtendsInterfaces(AExtendsExtendsInterfaces node)
01397     {
01398         inAExtendsExtendsInterfaces(node);
01399         if(node.getInterfaceType() != null)
01400         {
01401             node.getInterfaceType().apply(this);
01402         }
01403         if(node.getExtends() != null)
01404         {
01405             node.getExtends().apply(this);
01406         }
01407         outAExtendsExtendsInterfaces(node);
01408     }
01409     public void caseAExtendsInterfacesExtendsInterfaces(AExtendsInterfacesExtendsInterfaces node)
01410     {
01411         inAExtendsInterfacesExtendsInterfaces(node);
01412         if(node.getInterfaceType() != null)
01413         {
01414             node.getInterfaceType().apply(this);
01415         }
01416         if(node.getComma() != null)
01417         {
01418             node.getComma().apply(this);
01419         }
01420         if(node.getExtendsInterfaces() != null)
01421         {
01422             node.getExtendsInterfaces().apply(this);
01423         }
01424         outAExtendsInterfacesExtendsInterfaces(node);
01425     }
01426     public void caseAFalseBooleanLiteral(AFalseBooleanLiteral node)
01427     {
01428         inAFalseBooleanLiteral(node);
01429         if(node.getFalse() != null)
01430         {
01431             node.getFalse().apply(this);
01432         }
01433         outAFalseBooleanLiteral(node);
01434     }
01435     public void caseAFieldAccessExp(AFieldAccessExp node)
01436     {
01437         inAFieldAccessExp(node);
01438         if(node.getFieldAccess() != null)
01439         {
01440             node.getFieldAccess().apply(this);
01441         }
01442         outAFieldAccessExp(node);
01443     }
01444     public void caseAFieldAccessLeftHandSide(AFieldAccessLeftHandSide node)
01445     {
01446         inAFieldAccessLeftHandSide(node);
01447         if(node.getFieldAccess() != null)
01448         {
01449             node.getFieldAccess().apply(this);
01450         }
01451         outAFieldAccessLeftHandSide(node);
01452     }
01453     public void caseAFieldAccessPrimaryNoNewArray(AFieldAccessPrimaryNoNewArray node)
01454     {
01455         inAFieldAccessPrimaryNoNewArray(node);
01456         if(node.getFieldAccess() != null)
01457         {
01458             node.getFieldAccess().apply(this);
01459         }
01460         outAFieldAccessPrimaryNoNewArray(node);
01461     }
01462     public void caseAFieldClassBodyDeclaration(AFieldClassBodyDeclaration node)
01463     {
01464         inAFieldClassBodyDeclaration(node);
01465         if(node.getFieldDeclaration() != null)
01466         {
01467             node.getFieldDeclaration().apply(this);
01468         }
01469         outAFieldClassBodyDeclaration(node);
01470     }
01471     public void caseAFieldDeclaration(AFieldDeclaration node)
01472     {
01473         inAFieldDeclaration(node);
01474         if(node.getSemicolon() != null)
01475         {
01476             node.getSemicolon().apply(this);
01477         }
01478         {
01479             Object temp[] = node.getVariableDeclarator().toArray();
01480             for(int i = temp.length - 1; i >= 0; i--)
01481             {
01482                 ((PVariableDeclarator) temp[i]).apply(this);
01483             }
01484         }
01485         if(node.getType() != null)
01486         {
01487             node.getType().apply(this);
01488         }
01489         {
01490             Object temp[] = node.getModifier().toArray();
01491             for(int i = temp.length - 1; i >= 0; i--)
01492             {
01493                 ((PModifier) temp[i]).apply(this);
01494             }
01495         }
01496         outAFieldDeclaration(node);
01497     }
01498     public void caseAFieldDeclarationClassMemberDeclaration(AFieldDeclarationClassMemberDeclaration node)
01499     {
01500         inAFieldDeclarationClassMemberDeclaration(node);
01501         if(node.getFieldDeclaration() != null)
01502         {
01503             node.getFieldDeclaration().apply(this);
01504         }
01505         outAFieldDeclarationClassMemberDeclaration(node);
01506     }
01507     public void caseAFinally(AFinally node)
01508     {
01509         inAFinally(node);
01510         if(node.getBlock() != null)
01511         {
01512             node.getBlock().apply(this);
01513         }
01514         if(node.getFinally() != null)
01515         {
01516             node.getFinally().apply(this);
01517         }
01518         outAFinally(node);
01519     }
01520     public void caseAFinallyOneTryStmt(AFinallyOneTryStmt node)
01521     {
01522         inAFinallyOneTryStmt(node);
01523         if(node.getFinally() != null)
01524         {
01525             node.getFinally().apply(this);
01526         }
01527         {
01528             Object temp[] = node.getCatchClause().toArray();
01529             for(int i = temp.length - 1; i >= 0; i--)
01530             {
01531                 ((PCatchClause) temp[i]).apply(this);
01532             }
01533         }
01534         if(node.getBlock() != null)
01535         {
01536             node.getBlock().apply(this);
01537         }
01538         if(node.getTry() != null)
01539         {
01540             node.getTry().apply(this);
01541         }
01542         outAFinallyOneTryStmt(node);
01543     }
01544     public void caseAFinalModifier(AFinalModifier node)
01545     {
01546         inAFinalModifier(node);
01547         if(node.getFinal() != null)
01548         {
01549             node.getFinal().apply(this);
01550         }
01551         outAFinalModifier(node);
01552     }
01553     public void caseAFloatFloatingPointType(AFloatFloatingPointType node)
01554     {
01555         inAFloatFloatingPointType(node);
01556         if(node.getFloat() != null)
01557         {
01558             node.getFloat().apply(this);
01559         }
01560         outAFloatFloatingPointType(node);
01561     }
01562     public void caseAFloatingPointLiteralLiteral(AFloatingPointLiteralLiteral node)
01563     {
01564         inAFloatingPointLiteralLiteral(node);
01565         if(node.getFloatingPointLiteral() != null)
01566         {
01567             node.getFloatingPointLiteral().apply(this);
01568         }
01569         outAFloatingPointLiteralLiteral(node);
01570     }
01571     public void caseAFloatingPointTypeNumericType(AFloatingPointTypeNumericType node)
01572     {
01573         inAFloatingPointTypeNumericType(node);
01574         if(node.getFloatingPointType() != null)
01575         {
01576             node.getFloatingPointType().apply(this);
01577         }
01578         outAFloatingPointTypeNumericType(node);
01579     }
01580     public void caseAFloatPrimitiveType(AFloatPrimitiveType node)
01581     {
01582         inAFloatPrimitiveType(node);
01583         if(node.getFloat() != null)
01584         {
01585             node.getFloat().apply(this);
01586         }
01587         outAFloatPrimitiveType(node);
01588     }
01589     public void caseAFormalParameter(AFormalParameter node)
01590     {
01591         inAFormalParameter(node);
01592         if(node.getVariableDeclaratorId() != null)
01593         {
01594             node.getVariableDeclaratorId().apply(this);
01595         }
01596         if(node.getType() != null)
01597         {
01598             node.getType().apply(this);
01599         }
01600         {
01601             Object temp[] = node.getModifier().toArray();
01602             for(int i = temp.length - 1; i >= 0; i--)
01603             {
01604                 ((PModifier) temp[i]).apply(this);
01605             }
01606         }
01607         outAFormalParameter(node);
01608     }
01609     public void caseAFormalParameterFormalParameterList(AFormalParameterFormalParameterList node)
01610     {
01611         inAFormalParameterFormalParameterList(node);
01612         if(node.getFormalParameter() != null)
01613         {
01614             node.getFormalParameter().apply(this);
01615         }
01616         outAFormalParameterFormalParameterList(node);
01617     }
01618     public void caseAFormalParameterListFormalParameterList(AFormalParameterListFormalParameterList node)
01619     {
01620         inAFormalParameterListFormalParameterList(node);
01621         if(node.getFormalParameter() != null)
01622         {
01623             node.getFormalParameter().apply(this);
01624         }
01625         if(node.getComma() != null)
01626         {
01627             node.getComma().apply(this);
01628         }
01629         if(node.getFormalParameterList() != null)
01630         {
01631             node.getFormalParameterList().apply(this);
01632         }
01633         outAFormalParameterListFormalParameterList(node);
01634     }
01635     public void caseAForStmt(AForStmt node)
01636     {
01637         inAForStmt(node);
01638         if(node.getBlock() != null)
01639         {
01640             node.getBlock().apply(this);
01641         }
01642         if(node.getRPar() != null)
01643         {
01644             node.getRPar().apply(this);
01645         }
01646         {
01647             Object temp[] = node.getForUpdate().toArray();
01648             for(int i = temp.length - 1; i >= 0; i--)
01649             {
01650                 ((PExp) temp[i]).apply(this);
01651             }
01652         }
01653         if(node.getSemicolon2() != null)
01654         {
01655             node.getSemicolon2().apply(this);
01656         }
01657         if(node.getExp() != null)
01658         {
01659             node.getExp().apply(this);
01660         }
01661         if(node.getSemicolon1() != null)
01662         {
01663             node.getSemicolon1().apply(this);
01664         }
01665         if(node.getForInit() != null)
01666         {
01667             node.getForInit().apply(this);
01668         }
01669         if(node.getLPar() != null)
01670         {
01671             node.getLPar().apply(this);
01672         }
01673         if(node.getFor() != null)
01674         {
01675             node.getFor().apply(this);
01676         }
01677         outAForStmt(node);
01678     }
01679     public void caseAForStmtNoShortIf(AForStmtNoShortIf node)
01680     {
01681         inAForStmtNoShortIf(node);
01682         if(node.getStmtNoShortIf() != null)
01683         {
01684             node.getStmtNoShortIf().apply(this);
01685         }
01686         if(node.getRPar() != null)
01687         {
01688             node.getRPar().apply(this);
01689         }
01690         if(node.getForUpdate() != null)
01691         {
01692             node.getForUpdate().apply(this);
01693         }
01694         if(node.getSemicolon2() != null)
01695         {
01696             node.getSemicolon2().apply(this);
01697         }
01698         if(node.getExp() != null)
01699         {
01700             node.getExp().apply(this);
01701         }
01702         if(node.getSemicolon1() != null)
01703         {
01704             node.getSemicolon1().apply(this);
01705         }
01706         if(node.getForInit() != null)
01707         {
01708             node.getForInit().apply(this);
01709         }
01710         if(node.getLPar() != null)
01711         {
01712             node.getLPar().apply(this);
01713         }
01714         if(node.getFor() != null)
01715         {
01716             node.getFor().apply(this);
01717         }
01718         outAForStmtNoShortIf(node);
01719     }
01720     public void caseAForStmtNoShortIfStmtNoShortIf(AForStmtNoShortIfStmtNoShortIf node)
01721     {
01722         inAForStmtNoShortIfStmtNoShortIf(node);
01723         if(node.getForStmtNoShortIf() != null)
01724         {
01725             node.getForStmtNoShortIf().apply(this);
01726         }
01727         outAForStmtNoShortIfStmtNoShortIf(node);
01728     }
01729     public void caseAForStmtStmt(AForStmtStmt node)
01730     {
01731         inAForStmtStmt(node);
01732         if(node.getOneForStmt() != null)
01733         {
01734             node.getOneForStmt().apply(this);
01735         }
01736         outAForStmtStmt(node);
01737     }
01738     public void caseAForUpdate(AForUpdate node)
01739     {
01740         inAForUpdate(node);
01741         if(node.getStmtExpList() != null)
01742         {
01743             node.getStmtExpList().apply(this);
01744         }
01745         outAForUpdate(node);
01746     }
01747     public void caseAGtBinaryOperator(AGtBinaryOperator node)
01748     {
01749         inAGtBinaryOperator(node);
01750         if(node.getGt() != null)
01751         {
01752             node.getGt().apply(this);
01753         }
01754         outAGtBinaryOperator(node);
01755     }
01756     public void caseAGteqBinaryOperator(AGteqBinaryOperator node)
01757     {
01758         inAGteqBinaryOperator(node);
01759         if(node.getGteq() != null)
01760         {
01761             node.getGteq().apply(this);
01762         }
01763         outAGteqBinaryOperator(node);
01764     }
01765     public void caseAGteqRelationalExp(AGteqRelationalExp node)
01766     {
01767         inAGteqRelationalExp(node);
01768         if(node.getShiftExp() != null)
01769         {
01770             node.getShiftExp().apply(this);
01771         }
01772         if(node.getGteq() != null)
01773         {
01774             node.getGteq().apply(this);
01775         }
01776         if(node.getRelationalExp() != null)
01777         {
01778             node.getRelationalExp().apply(this);
01779         }
01780         outAGteqRelationalExp(node);
01781     }
01782     public void caseAGtRelationalExp(AGtRelationalExp node)
01783     {
01784         inAGtRelationalExp(node);
01785         if(node.getShiftExp() != null)
01786         {
01787             node.getShiftExp().apply(this);
01788         }
01789         if(node.getGt() != null)
01790         {
01791             node.getGt().apply(this);
01792         }
01793         if(node.getRelationalExp() != null)
01794         {
01795             node.getRelationalExp().apply(this);
01796         }
01797         outAGtRelationalExp(node);
01798     }
01799     public void caseAHexIntegerLiteral(AHexIntegerLiteral node)
01800     {
01801         inAHexIntegerLiteral(node);
01802         if(node.getHexIntegerLiteral() != null)
01803         {
01804             node.getHexIntegerLiteral().apply(this);
01805         }
01806         outAHexIntegerLiteral(node);
01807     }
01808     public void caseAIdVariableDeclarator(AIdVariableDeclarator node)
01809     {
01810         inAIdVariableDeclarator(node);
01811         if(node.getVariableDeclaratorId() != null)
01812         {
01813             node.getVariableDeclaratorId().apply(this);
01814         }
01815         outAIdVariableDeclarator(node);
01816     }
01817     public void caseAIfStmt(AIfStmt node)
01818     {
01819         inAIfStmt(node);
01820         if(node.getBlock() != null)
01821         {
01822             node.getBlock().apply(this);
01823         }
01824         if(node.getElse() != null)
01825         {
01826             node.getElse().apply(this);
01827         }
01828         if(node.getThenPart() != null)
01829         {
01830             node.getThenPart().apply(this);
01831         }
01832         if(node.getRPar() != null)
01833         {
01834             node.getRPar().apply(this);
01835         }
01836         if(node.getExp() != null)
01837         {
01838             node.getExp().apply(this);
01839         }
01840         if(node.getLPar() != null)
01841         {
01842             node.getLPar().apply(this);
01843         }
01844         if(node.getIf() != null)
01845         {
01846             node.getIf().apply(this);
01847         }
01848         outAIfStmt(node);
01849     }
01850     public void caseAIfThenElseStmt(AIfThenElseStmt node)
01851     {
01852         inAIfThenElseStmt(node);
01853         if(node.getStmt() != null)
01854         {
01855             node.getStmt().apply(this);
01856         }
01857         if(node.getElse() != null)
01858         {
01859             node.getElse().apply(this);
01860         }
01861         if(node.getStmtNoShortIf() != null)
01862         {
01863             node.getStmtNoShortIf().apply(this);
01864         }
01865         if(node.getRPar() != null)
01866         {
01867             node.getRPar().apply(this);
01868         }
01869         if(node.getExp() != null)
01870         {
01871             node.getExp().apply(this);
01872         }
01873         if(node.getLPar() != null)
01874         {
01875             node.getLPar().apply(this);
01876         }
01877         if(node.getIf() != null)
01878         {
01879             node.getIf().apply(this);
01880         }
01881         outAIfThenElseStmt(node);
01882     }
01883     public void caseAIfThenElseStmtNoShortIf(AIfThenElseStmtNoShortIf node)
01884     {
01885         inAIfThenElseStmtNoShortIf(node);
01886         if(node.getStmtNoShortIf2() != null)
01887         {
01888             node.getStmtNoShortIf2().apply(this);
01889         }
01890         if(node.getElse() != null)
01891         {
01892             node.getElse().apply(this);
01893         }
01894         if(node.getStmtNoShortIf1() != null)
01895         {
01896             node.getStmtNoShortIf1().apply(this);
01897         }
01898         if(node.getRPar() != null)
01899         {
01900             node.getRPar().apply(this);
01901         }
01902         if(node.getExp() != null)
01903         {
01904             node.getExp().apply(this);
01905         }
01906         if(node.getLPar() != null)
01907         {
01908             node.getLPar().apply(this);
01909         }
01910         if(node.getIf() != null)
01911         {
01912             node.getIf().apply(this);
01913         }
01914         outAIfThenElseStmtNoShortIf(node);
01915     }
01916     public void caseAIfThenElseStmtNoShortIfStmtNoShortIf(AIfThenElseStmtNoShortIfStmtNoShortIf node)
01917     {
01918         inAIfThenElseStmtNoShortIfStmtNoShortIf(node);
01919         if(node.getIfThenElseStmtNoShortIf() != null)
01920         {
01921             node.getIfThenElseStmtNoShortIf().apply(this);
01922         }
01923         outAIfThenElseStmtNoShortIfStmtNoShortIf(node);
01924     }
01925     public void caseAIfThenElseStmtStmt(AIfThenElseStmtStmt node)
01926     {
01927         inAIfThenElseStmtStmt(node);
01928         if(node.getIfThenElseStmt() != null)
01929         {
01930             node.getIfThenElseStmt().apply(this);
01931         }
01932         outAIfThenElseStmtStmt(node);
01933     }
01934     public void caseAIfThenStmt(AIfThenStmt node)
01935     {
01936         inAIfThenStmt(node);
01937         if(node.getStmt() != null)
01938         {
01939             node.getStmt().apply(this);
01940         }
01941         if(node.getRPar() != null)
01942         {
01943             node.getRPar().apply(this);
01944         }
01945         if(node.getExp() != null)
01946         {
01947             node.getExp().apply(this);
01948         }
01949         if(node.getLPar() != null)
01950         {
01951             node.getLPar().apply(this);
01952         }
01953         if(node.getIf() != null)
01954         {
01955             node.getIf().apply(this);
01956         }
01957         outAIfThenStmt(node);
01958     }
01959     public void caseAIfThenStmtStmt(AIfThenStmtStmt node)
01960     {
01961         inAIfThenStmtStmt(node);
01962         if(node.getIfThenStmt() != null)
01963         {
01964             node.getIfThenStmt().apply(this);
01965         }
01966         outAIfThenStmtStmt(node);
01967     }
01968     public void caseAInclusiveOrExpConditionalAndExp(AInclusiveOrExpConditionalAndExp node)
01969     {
01970         inAInclusiveOrExpConditionalAndExp(node);
01971         if(node.getInclusiveOrExp() != null)
01972         {
01973             node.getInclusiveOrExp().apply(this);
01974         }
01975         outAInclusiveOrExpConditionalAndExp(node);
01976     }
01977     public void caseAInclusiveOrExpInclusiveOrExp(AInclusiveOrExpInclusiveOrExp node)
01978     {
01979         inAInclusiveOrExpInclusiveOrExp(node);
01980         if(node.getExclusiveOrExp() != null)
01981         {
01982             node.getExclusiveOrExp().apply(this);
01983         }
01984         if(node.getBitOr() != null)
01985         {
01986             node.getBitOr().apply(this);
01987         }
01988         if(node.getInclusiveOrExp() != null)
01989         {
01990             node.getInclusiveOrExp().apply(this);
01991         }
01992         outAInclusiveOrExpInclusiveOrExp(node);
01993     }
01994     public void caseAIncrementUnaryOperator(AIncrementUnaryOperator node)
01995     {
01996         inAIncrementUnaryOperator(node);
01997         if(node.getPlusPlus() != null)
01998         {
01999             node.getPlusPlus().apply(this);
02000         }
02001         outAIncrementUnaryOperator(node);
02002     }
02003     public void caseAInitClassInterfaceArrayCreationExp(AInitClassInterfaceArrayCreationExp node)
02004     {
02005         inAInitClassInterfaceArrayCreationExp(node);
02006         if(node.getArrayInitializer() != null)
02007         {
02008             node.getArrayInitializer().apply(this);
02009         }
02010         {
02011             Object temp[] = node.getDim().toArray();
02012             for(int i = temp.length - 1; i >= 0; i--)
02013             {
02014                 ((PDim) temp[i]).apply(this);
02015             }
02016         }
02017         if(node.getClassOrInterfaceType() != null)
02018         {
02019             node.getClassOrInterfaceType().apply(this);
02020         }
02021         if(node.getNew() != null)
02022         {
02023             node.getNew().apply(this);
02024         }
02025         outAInitClassInterfaceArrayCreationExp(node);
02026     }
02027     public void caseAInitClassInterfaceExp(AInitClassInterfaceExp node)
02028     {
02029         inAInitClassInterfaceExp(node);
02030         if(node.getArrayInitializer() != null)
02031         {
02032             node.getArrayInitializer().apply(this);
02033         }
02034         {
02035             Object temp[] = node.getDim().toArray();
02036             for(int i = temp.length - 1; i >= 0; i--)
02037             {
02038                 ((PDim) temp[i]).apply(this);
02039             }
02040         }
02041         if(node.getClassOrInterfaceType() != null)
02042         {
02043             node.getClassOrInterfaceType().apply(this);
02044         }
02045         if(node.getNew() != null)
02046         {
02047             node.getNew().apply(this);
02048         }
02049         outAInitClassInterfaceExp(node);
02050     }
02051     public void caseAInitPrimitiveArrayCreationExp(AInitPrimitiveArrayCreationExp node)
02052     {
02053         inAInitPrimitiveArrayCreationExp(node);
02054         if(node.getArrayInitializer() != null)
02055         {
02056             node.getArrayInitializer().apply(this);
02057         }
02058         {
02059             Object temp[] = node.getDim().toArray();
02060             for(int i = temp.length - 1; i >= 0; i--)
02061             {
02062                 ((PDim) temp[i]).apply(this);
02063             }
02064         }
02065         if(node.getPrimitiveType() != null)
02066         {
02067             node.getPrimitiveType().apply(this);
02068         }
02069         if(node.getNew() != null)
02070         {
02071             node.getNew().apply(this);
02072         }
02073         outAInitPrimitiveArrayCreationExp(node);
02074     }
02075     public void caseAInitPrimitiveExp(AInitPrimitiveExp node)
02076     {
02077         inAInitPrimitiveExp(node);
02078         if(node.getArrayInitializer() != null)
02079         {
02080             node.getArrayInitializer().apply(this);
02081         }
02082         {
02083             Object temp[] = node.getDim().toArray();
02084             for(int i = temp.length - 1; i >= 0; i--)
02085             {
02086                 ((PDim) temp[i]).apply(this);
02087             }
02088         }
02089         if(node.getPrimitiveType() != null)
02090         {
02091             node.getPrimitiveType().apply(this);
02092         }
02093         if(node.getNew() != null)
02094         {
02095             node.getNew().apply(this);
02096         }
02097         outAInitPrimitiveExp(node);
02098     }
02099     public void caseAInstanceofExp(AInstanceofExp node)
02100     {
02101         inAInstanceofExp(node);
02102         if(node.getReferenceType() != null)
02103         {
02104             node.getReferenceType().apply(this);
02105         }
02106         if(node.getInstanceof() != null)
02107         {
02108             node.getInstanceof().apply(this);
02109         }
02110         if(node.getExp() != null)
02111         {
02112             node.getExp().apply(this);
02113         }
02114         outAInstanceofExp(node);
02115     }
02116     public void caseAInstanceofRelationalExp(AInstanceofRelationalExp node)
02117     {
02118         inAInstanceofRelationalExp(node);
02119         if(node.getReferenceType() != null)
02120         {
02121             node.getReferenceType().apply(this);
02122         }
02123         if(node.getInstanceof() != null)
02124         {
02125             node.getInstanceof().apply(this);
02126         }
02127         if(node.getRelationalExp() != null)
02128         {
02129             node.getRelationalExp().apply(this);
02130         }
02131         outAInstanceofRelationalExp(node);
02132     }
02133     public void caseAIntegerLiteralLiteral(AIntegerLiteralLiteral node)
02134     {
02135         inAIntegerLiteralLiteral(node);
02136         if(node.getIntegerLiteral() != null)
02137         {
02138             node.getIntegerLiteral().apply(this);
02139         }
02140         outAIntegerLiteralLiteral(node);
02141     }
02142     public void caseAIntegralTypeNumericType(AIntegralTypeNumericType node)
02143     {
02144         inAIntegralTypeNumericType(node);
02145         if(node.getIntegralType() != null)
02146         {
02147             node.getIntegralType().apply(this);
02148         }
02149         outAIntegralTypeNumericType(node);
02150     }
02151     public void caseAInterfaceBody(AInterfaceBody node)
02152     {
02153         inAInterfaceBody(node);
02154         if(node.getRBrace() != null)
02155         {
02156             node.getRBrace().apply(this);
02157         }
02158         {
02159             Object temp[] = node.getInterfaceMemberDeclaration().toArray();
02160             for(int i = temp.length - 1; i >= 0; i--)
02161             {
02162                 ((PInterfaceMemberDeclaration) temp[i]).apply(this);
02163             }
02164         }
02165         if(node.getLBrace() != null)
02166         {
02167             node.getLBrace().apply(this);
02168         }
02169         outAInterfaceBody(node);
02170     }
02171     public void caseAInterfaceClassBodyDeclaration(AInterfaceClassBodyDeclaration node)
02172     {
02173         inAInterfaceClassBodyDeclaration(node);
02174         if(node.getInterfaceDeclaration() != null)
02175         {
02176             node.getInterfaceDeclaration().apply(this);
02177         }
02178         outAInterfaceClassBodyDeclaration(node);
02179     }
02180     public void caseAInterfaceDeclaration(AInterfaceDeclaration node)
02181     {
02182         inAInterfaceDeclaration(node);
02183         if(node.getInterfaceBody() != null)
02184         {
02185             node.getInterfaceBody().apply(this);
02186         }
02187         {
02188             Object temp[] = node.getName().toArray();
02189             for(int i = temp.length - 1; i >= 0; i--)
02190             {
02191                 ((PName) temp[i]).apply(this);
02192             }
02193         }
02194         if(node.getExtends() != null)
02195         {
02196             node.getExtends().apply(this);
02197         }
02198         if(node.getId() != null)
02199         {
02200             node.getId().apply(this);
02201         }
02202         if(node.getInterface() != null)
02203         {
02204             node.getInterface().apply(this);
02205         }
02206         {
02207             Object temp[] = node.getModifier().toArray();
02208             for(int i = temp.length - 1; i >= 0; i--)
02209             {
02210                 ((PModifier) temp[i]).apply(this);
02211             }
02212         }
02213         outAInterfaceDeclaration(node);
02214     }
02215     public void caseAInterfaceDeclarationClassMemberDeclaration(AInterfaceDeclarationClassMemberDeclaration node)
02216     {
02217         inAInterfaceDeclarationClassMemberDeclaration(node);
02218         if(node.getInterfaceDeclaration() != null)
02219         {
02220             node.getInterfaceDeclaration().apply(this);
02221         }
02222         outAInterfaceDeclarationClassMemberDeclaration(node);
02223     }
02224     public void caseAInterfaceDeclarationInterfaceMemberDeclaration(AInterfaceDeclarationInterfaceMemberDeclaration node)
02225     {
02226         inAInterfaceDeclarationInterfaceMemberDeclaration(node);
02227         if(node.getInterfaceDeclaration() != null)
02228         {
02229             node.getInterfaceDeclaration().apply(this);
02230         }
02231         outAInterfaceDeclarationInterfaceMemberDeclaration(node);
02232     }
02233     public void caseAInterfaces(AInterfaces node)
02234     {
02235         inAInterfaces(node);
02236         {
02237             Object temp[] = node.getName().toArray();
02238             for(int i = temp.length - 1; i >= 0; i--)
02239             {
02240                 ((PName) temp[i]).apply(this);
02241             }
02242         }
02243         if(node.getImplements() != null)
02244         {
02245             node.getImplements().apply(this);
02246         }
02247         outAInterfaces(node);
02248     }
02249     public void caseAInterfaceType(AInterfaceType node)
02250     {
02251         inAInterfaceType(node);
02252         if(node.getClassOrInterfaceType() != null)
02253         {
02254             node.getClassOrInterfaceType().apply(this);
02255         }
02256         outAInterfaceType(node);
02257     }
02258     public void caseAInterfaceTypeDeclaration(AInterfaceTypeDeclaration node)
02259     {
02260         inAInterfaceTypeDeclaration(node);
02261         if(node.getInterfaceDeclaration() != null)
02262         {
02263             node.getInterfaceDeclaration().apply(this);
02264         }
02265         outAInterfaceTypeDeclaration(node);
02266     }
02267     public void caseAInterfaceTypeInterfaceTypeList(AInterfaceTypeInterfaceTypeList node)
02268     {
02269         inAInterfaceTypeInterfaceTypeList(node);
02270         if(node.getInterfaceType() != null)
02271         {
02272             node.getInterfaceType().apply(this);
02273         }
02274         outAInterfaceTypeInterfaceTypeList(node);
02275     }
02276     public void caseAInterfaceTypeListInterfaceTypeList(AInterfaceTypeListInterfaceTypeList node)
02277     {
02278         inAInterfaceTypeListInterfaceTypeList(node);
02279         if(node.getInterfaceType() != null)
02280         {
02281             node.getInterfaceType().apply(this);
02282         }
02283         if(node.getComma() != null)
02284         {
02285             node.getComma().apply(this);
02286         }
02287         if(node.getInterfaceTypeList() != null)
02288         {
02289             node.getInterfaceTypeList().apply(this);
02290         }
02291         outAInterfaceTypeListInterfaceTypeList(node);
02292     }
02293     public void caseAIntIntegralType(AIntIntegralType node)
02294     {
02295         inAIntIntegralType(node);
02296         if(node.getInt() != null)
02297         {
02298             node.getInt().apply(this);
02299         }
02300         outAIntIntegralType(node);
02301     }
02302     public void caseAIntPrimitiveType(AIntPrimitiveType node)
02303     {
02304         inAIntPrimitiveType(node);
02305         if(node.getInt() != null)
02306         {
02307             node.getInt().apply(this);
02308         }
02309         outAIntPrimitiveType(node);
02310     }
02311     public void caseALabeledStmt(ALabeledStmt node)
02312     {
02313         inALabeledStmt(node);
02314         if(node.getStmt() != null)
02315         {
02316             node.getStmt().apply(this);
02317         }
02318         if(node.getColon() != null)
02319         {
02320             node.getColon().apply(this);
02321         }
02322         if(node.getId() != null)
02323         {
02324             node.getId().apply(this);
02325         }
02326         outALabeledStmt(node);
02327     }
02328     public void caseALabeledStmtNoShortIf(ALabeledStmtNoShortIf node)
02329     {
02330         inALabeledStmtNoShortIf(node);
02331         if(node.getStmtNoShortIf() != null)
02332         {
02333             node.getStmtNoShortIf().apply(this);
02334         }
02335         if(node.getColon() != null)
02336         {
02337             node.getColon().apply(this);
02338         }
02339         if(node.getId() != null)
02340         {
02341             node.getId().apply(this);
02342         }
02343         outALabeledStmtNoShortIf(node);
02344     }
02345     public void caseALabeledStmtNoShortIfStmtNoShortIf(ALabeledStmtNoShortIfStmtNoShortIf node)
02346     {
02347         inALabeledStmtNoShortIfStmtNoShortIf(node);
02348         if(node.getLabeledStmtNoShortIf() != null)
02349         {
02350             node.getLabeledStmtNoShortIf().apply(this);
02351         }
02352         outALabeledStmtNoShortIfStmtNoShortIf(node);
02353     }
02354     public void caseALabeledStmtStmt(ALabeledStmtStmt node)
02355     {
02356         inALabeledStmtStmt(node);
02357         if(node.getLabeledStmt() != null)
02358         {
02359             node.getLabeledStmt().apply(this);
02360         }
02361         outALabeledStmtStmt(node);
02362     }
02363     public void caseALabelStmt(ALabelStmt node)
02364     {
02365         inALabelStmt(node);
02366         if(node.getBlock() != null)
02367         {
02368             node.getBlock().apply(this);
02369         }
02370         if(node.getColon() != null)
02371         {
02372             node.getColon().apply(this);
02373         }
02374         if(node.getId() != null)
02375         {
02376             node.getId().apply(this);
02377         }
02378         outALabelStmt(node);
02379     }
02380     public void caseALiteralExp(ALiteralExp node)
02381     {
02382         inALiteralExp(node);
02383         if(node.getLiteral() != null)
02384         {
02385             node.getLiteral().apply(this);
02386         }
02387         outALiteralExp(node);
02388     }
02389     public void caseALiteralPrimaryNoNewArray(ALiteralPrimaryNoNewArray node)
02390     {
02391         inALiteralPrimaryNoNewArray(node);
02392         if(node.getLiteral() != null)
02393         {
02394             node.getLiteral().apply(this);
02395         }
02396         outALiteralPrimaryNoNewArray(node);
02397     }
02398     public void caseALocalVariableDeclaration(ALocalVariableDeclaration node)
02399     {
02400         inALocalVariableDeclaration(node);
02401         {
02402             Object temp[] = node.getVariableDeclarator().toArray();
02403             for(int i = temp.length - 1; i >= 0; i--)
02404             {
02405                 ((PVariableDeclarator) temp[i]).apply(this);
02406             }
02407         }
02408         if(node.getType() != null)
02409         {
02410             node.getType().apply(this);
02411         }
02412         {
02413             Object temp[] = node.getModifier().toArray();
02414             for(int i = temp.length - 1; i >= 0; i--)
02415             {
02416                 ((PModifier) temp[i]).apply(this);
02417             }
02418         }
02419         outALocalVariableDeclaration(node);
02420     }
02421     public void caseALocalVariableDeclarationForInit(ALocalVariableDeclarationForInit node)
02422     {
02423         inALocalVariableDeclarationForInit(node);
02424         if(node.getLocalVariableDeclaration() != null)
02425         {
02426             node.getLocalVariableDeclaration().apply(this);
02427         }
02428         outALocalVariableDeclarationForInit(node);
02429     }
02430     public void caseALocalVariableDeclarationInBlockedStmt(ALocalVariableDeclarationInBlockedStmt node)
02431     {
02432         inALocalVariableDeclarationInBlockedStmt(node);
02433         if(node.getSemicolon() != null)
02434         {
02435             node.getSemicolon().apply(this);
02436         }
02437         if(node.getLocalVariableDeclaration() != null)
02438         {
02439             node.getLocalVariableDeclaration().apply(this);
02440         }
02441         outALocalVariableDeclarationInBlockedStmt(node);
02442     }
02443     public void caseALocalVariableDeclarationStmt(ALocalVariableDeclarationStmt node)
02444     {
02445         inALocalVariableDeclarationStmt(node);
02446         if(node.getSemicolon() != null)
02447         {
02448             node.getSemicolon().apply(this);
02449         }
02450         if(node.getLocalVariableDeclaration() != null)
02451         {
02452             node.getLocalVariableDeclaration().apply(this);
02453         }
02454         outALocalVariableDeclarationStmt(node);
02455     }
02456     public void caseALocalVariableDeclarationStmtBlockedStmt(ALocalVariableDeclarationStmtBlockedStmt node)
02457     {
02458         inALocalVariableDeclarationStmtBlockedStmt(node);
02459         if(node.getLocalVariableDeclarationStmt() != null)
02460         {
02461             node.getLocalVariableDeclarationStmt().apply(this);
02462         }
02463         outALocalVariableDeclarationStmtBlockedStmt(node);
02464     }
02465     public void caseALongIntegralType(ALongIntegralType node)
02466     {
02467         inALongIntegralType(node);
02468         if(node.getLong() != null)
02469         {
02470             node.getLong().apply(this);
02471         }
02472         outALongIntegralType(node);
02473     }
02474     public void caseALongPrimitiveType(ALongPrimitiveType node)
02475     {
02476         inALongPrimitiveType(node);
02477         if(node.getLong() != null)
02478         {
02479             node.getLong().apply(this);
02480         }
02481         outALongPrimitiveType(node);
02482     }
02483     public void caseALParPrimaryNoNewArray(ALParPrimaryNoNewArray node)
02484     {
02485         inALParPrimaryNoNewArray(node);
02486         if(node.getRPar() != null)
02487         {
02488             node.getRPar().apply(this);
02489         }
02490         if(node.getExp() != null)
02491         {
02492             node.getExp().apply(this);
02493         }
02494         if(node.getLPar() != null)
02495         {
02496             node.getLPar().apply(this);
02497         }
02498         outALParPrimaryNoNewArray(node);
02499     }
02500     public void caseALtBinaryOperator(ALtBinaryOperator node)
02501     {
02502         inALtBinaryOperator(node);
02503         if(node.getLt() != null)
02504         {
02505             node.getLt().apply(this);
02506         }
02507         outALtBinaryOperator(node);
02508     }
02509     public void caseALteqBinaryOperator(ALteqBinaryOperator node)
02510     {
02511         inALteqBinaryOperator(node);
02512         if(node.getLteq() != null)
02513         {
02514             node.getLteq().apply(this);
02515         }
02516         outALteqBinaryOperator(node);
02517     }
02518     public void caseALteqRelationalExp(ALteqRelationalExp node)
02519     {
02520         inALteqRelationalExp(node);
02521         if(node.getShiftExp() != null)
02522         {
02523             node.getShiftExp().apply(this);
02524         }
02525         if(node.getLteq() != null)
02526         {
02527             node.getLteq().apply(this);
02528         }
02529         if(node.getRelationalExp() != null)
02530         {
02531             node.getRelationalExp().apply(this);
02532         }
02533         outALteqRelationalExp(node);
02534     }
02535     public void caseALtRelationalExp(ALtRelationalExp node)
02536     {
02537         inALtRelationalExp(node);
02538         if(node.getShiftExp() != null)
02539         {
02540             node.getShiftExp().apply(this);
02541         }
02542         if(node.getLt() != null)
02543         {
02544             node.getLt().apply(this);
02545         }
02546         if(node.getRelationalExp() != null)
02547         {
02548             node.getRelationalExp().apply(this);
02549         }
02550         outALtRelationalExp(node);
02551     }
02552     public void caseAMethodClassBodyDeclaration(AMethodClassBodyDeclaration node)
02553     {
02554         inAMethodClassBodyDeclaration(node);
02555         if(node.getMethodDeclaration() != null)
02556         {
02557             node.getMethodDeclaration().apply(this);
02558         }
02559         outAMethodClassBodyDeclaration(node);
02560     }
02561     public void caseAMethodDeclaration(AMethodDeclaration node)
02562     {
02563         inAMethodDeclaration(node);
02564         if(node.getMethodBody() != null)
02565         {
02566             node.getMethodBody().apply(this);
02567         }
02568         if(node.getMethodHeader() != null)
02569         {
02570             node.getMethodHeader().apply(this);
02571         }
02572         outAMethodDeclaration(node);
02573     }
02574     public void caseAMethodDeclarationClassMemberDeclaration(AMethodDeclarationClassMemberDeclaration node)
02575     {
02576         inAMethodDeclarationClassMemberDeclaration(node);
02577         if(node.getMethodDeclaration() != null)
02578         {
02579             node.getMethodDeclaration().apply(this);
02580         }
02581         outAMethodDeclarationClassMemberDeclaration(node);
02582     }
02583     public void caseAMethodDeclarator(AMethodDeclarator node)
02584     {
02585         inAMethodDeclarator(node);
02586         {
02587             Object temp[] = node.getDim().toArray();
02588             for(int i = temp.length - 1; i >= 0; i--)
02589             {
02590                 ((PDim) temp[i]).apply(this);
02591             }
02592         }
02593         if(node.getRPar() != null)
02594         {
02595             node.getRPar().apply(this);
02596         }
02597         {
02598             Object temp[] = node.getFormalParameter().toArray();
02599             for(int i = temp.length - 1; i >= 0; i--)
02600             {
02601                 ((PFormalParameter) temp[i]).apply(this);
02602             }
02603         }
02604         if(node.getLPar() != null)
02605         {
02606             node.getLPar().apply(this);
02607         }
02608         if(node.getId() != null)
02609         {
02610             node.getId().apply(this);
02611         }
02612         outAMethodDeclarator(node);
02613     }
02614     public void caseAMethodInvocationPrimaryNoNewArray(AMethodInvocationPrimaryNoNewArray node)
02615     {
02616         inAMethodInvocationPrimaryNoNewArray(node);
02617         if(node.getMethodInvocation() != null)
02618         {
02619             node.getMethodInvocation().apply(this);
02620         }
02621         outAMethodInvocationPrimaryNoNewArray(node);
02622     }
02623     public void caseAMethodInvocationStmtExp(AMethodInvocationStmtExp node)
02624     {
02625         inAMethodInvocationStmtExp(node);
02626         if(node.getMethodInvocation() != null)
02627         {
02628             node.getMethodInvocation().apply(this);
02629         }
02630         outAMethodInvocationStmtExp(node);
02631     }
02632     public void caseAMinusAdditiveExp(AMinusAdditiveExp node)
02633     {
02634         inAMinusAdditiveExp(node);
02635         if(node.getMultiplicativeExp() != null)
02636         {
02637             node.getMultiplicativeExp().apply(this);
02638         }
02639         if(node.getMinus() != null)
02640         {
02641             node.getMinus().apply(this);
02642         }
02643         if(node.getAdditiveExp() != null)
02644         {
02645             node.getAdditiveExp().apply(this);
02646         }
02647         outAMinusAdditiveExp(node);
02648     }
02649     public void caseAMinusAssignAssignmentOperator(AMinusAssignAssignmentOperator node)
02650     {
02651         inAMinusAssignAssignmentOperator(node);
02652         if(node.getMinusAssign() != null)
02653         {
02654             node.getMinusAssign().apply(this);
02655         }
02656         outAMinusAssignAssignmentOperator(node);
02657     }
02658     public void caseAMinusBinaryOperator(AMinusBinaryOperator node)
02659     {
02660         inAMinusBinaryOperator(node);
02661         if(node.getMinus() != null)
02662         {
02663             node.getMinus().apply(this);
02664         }
02665         outAMinusBinaryOperator(node);
02666     }
02667     public void caseAMinusUnaryExp(AMinusUnaryExp node)
02668     {
02669         inAMinusUnaryExp(node);
02670         if(node.getUnaryExp() != null)
02671         {
02672             node.getUnaryExp().apply(this);
02673         }
02674         if(node.getMinus() != null)
02675         {
02676             node.getMinus().apply(this);
02677         }
02678         outAMinusUnaryExp(node);
02679     }
02680     public void caseAMinusUnaryOperator(AMinusUnaryOperator node)
02681     {
02682         inAMinusUnaryOperator(node);
02683         if(node.getMinus() != null)
02684         {
02685             node.getMinus().apply(this);
02686         }
02687         outAMinusUnaryOperator(node);
02688     }
02689     public void caseAModAssignAssignmentOperator(AModAssignAssignmentOperator node)
02690     {
02691         inAModAssignAssignmentOperator(node);
02692         if(node.getModAssign() != null)
02693         {
02694             node.getModAssign().apply(this);
02695         }
02696         outAModAssignAssignmentOperator(node);
02697     }
02698     public void caseAModBinaryOperator(AModBinaryOperator node)
02699     {
02700         inAModBinaryOperator(node);
02701         if(node.getMod() != null)
02702         {
02703             node.getMod().apply(this);
02704         }
02705         outAModBinaryOperator(node);
02706     }
02707     public void caseAModMultiplicativeExp(AModMultiplicativeExp node)
02708     {
02709         inAModMultiplicativeExp(node);
02710         if(node.getUnaryExp() != null)
02711         {
02712             node.getUnaryExp().apply(this);
02713         }
02714         if(node.getMod() != null)
02715         {
02716             node.getMod().apply(this);
02717         }
02718         if(node.getMultiplicativeExp() != null)
02719         {
02720             node.getMultiplicativeExp().apply(this);
02721         }
02722         outAModMultiplicativeExp(node);
02723     }
02724     public void caseAMultiplicativeExpAdditiveExp(AMultiplicativeExpAdditiveExp node)
02725     {
02726         inAMultiplicativeExpAdditiveExp(node);
02727         if(node.getMultiplicativeExp() != null)
02728         {
02729             node.getMultiplicativeExp().apply(this);
02730         }
02731         outAMultiplicativeExpAdditiveExp(node);
02732     }
02733     public void caseANameArrayAccess(ANameArrayAccess node)
02734     {
02735         inANameArrayAccess(node);
02736         if(node.getRBracket() != null)
02737         {
02738             node.getRBracket().apply(this);
02739         }
02740         if(node.getExp() != null)
02741         {
02742             node.getExp().apply(this);
02743         }
02744         if(node.getLBracket() != null)
02745         {
02746             node.getLBracket().apply(this);
02747         }
02748         if(node.getName() != null)
02749         {
02750             node.getName().apply(this);
02751         }
02752         outANameArrayAccess(node);
02753     }
02754     public void caseANameArrayType(ANameArrayType node)
02755     {
02756         inANameArrayType(node);
02757         {
02758             Object temp[] = node.getDim().toArray();
02759             for(int i = temp.length - 1; i >= 0; i--)
02760             {
02761                 ((PDim) temp[i]).apply(this);
02762             }
02763         }
02764         if(node.getName() != null)
02765         {
02766             node.getName().apply(this);
02767         }
02768         outANameArrayType(node);
02769     }
02770     public void caseANameCastExp(ANameCastExp node)
02771     {
02772         inANameCastExp(node);
02773         if(node.getExp() != null)
02774         {
02775             node.getExp().apply(this);
02776         }
02777         if(node.getRPar() != null)
02778         {
02779             node.getRPar().apply(this);
02780         }
02781         {
02782             Object temp[] = node.getDim().toArray();
02783             for(int i = temp.length - 1; i >= 0; i--)
02784             {
02785                 ((PDim) temp[i]).apply(this);
02786             }
02787         }
02788         if(node.getName() != null)
02789         {
02790             node.getName().apply(this);
02791         }
02792         if(node.getLPar() != null)
02793         {
02794             node.getLPar().apply(this);
02795         }
02796         outANameCastExp(node);
02797     }
02798     public void caseANamedTypeExp(ANamedTypeExp node)
02799     {
02800         inANamedTypeExp(node);
02801         if(node.getTClass() != null)
02802         {
02803             node.getTClass().apply(this);
02804         }
02805         if(node.getDot() != null)
02806         {
02807             node.getDot().apply(this);
02808         }
02809         {
02810             Object temp[] = node.getDim().toArray();
02811             for(int i = temp.length - 1; i >= 0; i--)
02812             {
02813                 ((PDim) temp[i]).apply(this);
02814             }
02815         }
02816         if(node.getName() != null)
02817         {
02818             node.getName().apply(this);
02819         }
02820         outANamedTypeExp(node);
02821     }
02822     public void caseANameExp(ANameExp node)
02823     {
02824         inANameExp(node);
02825         if(node.getName() != null)
02826         {
02827             node.getName().apply(this);
02828         }
02829         outANameExp(node);
02830     }
02831     public void caseANameLeftHandSide(ANameLeftHandSide node)
02832     {
02833         inANameLeftHandSide(node);
02834         if(node.getName() != null)
02835         {
02836             node.getName().apply(this);
02837         }
02838         outANameLeftHandSide(node);
02839     }
02840     public void caseANameMethodInvocation(ANameMethodInvocation node)
02841     {
02842         inANameMethodInvocation(node);
02843         if(node.getRPar() != null)
02844         {
02845             node.getRPar().apply(this);
02846         }
02847         if(node.getArgumentList() != null)
02848         {
02849             node.getArgumentList().apply(this);
02850         }
02851         if(node.getLPar() != null)
02852         {
02853             node.getLPar().apply(this);
02854         }
02855         if(node.getName() != null)
02856         {
02857             node.getName().apply(this);
02858         }
02859         outANameMethodInvocation(node);
02860     }
02861     public void caseANameMethodInvocationExp(ANameMethodInvocationExp node)
02862     {
02863         inANameMethodInvocationExp(node);
02864         if(node.getRPar() != null)
02865         {
02866             node.getRPar().apply(this);
02867         }
02868         {
02869             Object temp[] = node.getArgumentList().toArray();
02870             for(int i = temp.length - 1; i >= 0; i--)
02871             {
02872                 ((PExp) temp[i]).apply(this);
02873             }
02874         }
02875         if(node.getLPar() != null)
02876         {
02877             node.getLPar().apply(this);
02878         }
02879         if(node.getName() != null)
02880         {
02881             node.getName().apply(this);
02882         }
02883         outANameMethodInvocationExp(node);
02884     }
02885     public void caseANamePostfixExp(ANamePostfixExp node)
02886     {
02887         inANamePostfixExp(node);
02888         if(node.getName() != null)
02889         {
02890             node.getName().apply(this);
02891         }
02892         outANamePostfixExp(node);
02893     }
02894     public void caseANameReferenceType(ANameReferenceType node)
02895     {
02896         inANameReferenceType(node);
02897         if(node.getName() != null)
02898         {
02899             node.getName().apply(this);
02900         }
02901         outANameReferenceType(node);
02902     }
02903     public void caseANativeModifier(ANativeModifier node)
02904     {
02905         inANativeModifier(node);
02906         if(node.getNative() != null)
02907         {
02908             node.getNative().apply(this);
02909         }
02910         outANativeModifier(node);
02911     }
02912     public void caseANeqBinaryOperator(ANeqBinaryOperator node)
02913     {
02914         inANeqBinaryOperator(node);
02915         if(node.getNeq() != null)
02916         {
02917             node.getNeq().apply(this);
02918         }
02919         outANeqBinaryOperator(node);
02920     }
02921     public void caseANeqEqualityExp(ANeqEqualityExp node)
02922     {
02923         inANeqEqualityExp(node);
02924         if(node.getRelationalExp() != null)
02925         {
02926             node.getRelationalExp().apply(this);
02927         }
02928         if(node.getNeq() != null)
02929         {
02930             node.getNeq().apply(this);
02931         }
02932         if(node.getEqualityExp() != null)
02933         {
02934             node.getEqualityExp().apply(this);
02935         }
02936         outANeqEqualityExp(node);
02937     }
02938     public void caseANotPlusMinusUnaryExp(ANotPlusMinusUnaryExp node)
02939     {
02940         inANotPlusMinusUnaryExp(node);
02941         if(node.getUnaryExpNotPlusMinus() != null)
02942         {
02943             node.getUnaryExpNotPlusMinus().apply(this);
02944         }
02945         outANotPlusMinusUnaryExp(node);
02946     }
02947     public void caseANullLiteral(ANullLiteral node)
02948     {
02949         inANullLiteral(node);
02950         if(node.getNull() != null)
02951         {
02952             node.getNull().apply(this);
02953         }
02954         outANullLiteral(node);
02955     }
02956     public void caseANullLiteralLiteral(ANullLiteralLiteral node)
02957     {
02958         inANullLiteralLiteral(node);
02959         if(node.getNullLiteral() != null)
02960         {
02961             node.getNullLiteral().apply(this);
02962         }
02963         outANullLiteralLiteral(node);
02964     }
02965     public void caseANumericTypePrimitiveType(ANumericTypePrimitiveType node)
02966     {
02967         inANumericTypePrimitiveType(node);
02968         if(node.getNumericType() != null)
02969         {
02970             node.getNumericType().apply(this);
02971         }
02972         outANumericTypePrimitiveType(node);
02973     }
02974     public void caseAOctalIntegerLiteral(AOctalIntegerLiteral node)
02975     {
02976         inAOctalIntegerLiteral(node);
02977         if(node.getOctalIntegerLiteral() != null)
02978         {
02979             node.getOctalIntegerLiteral().apply(this);
02980         }
02981         outAOctalIntegerLiteral(node);
02982     }
02983     public void caseAOldAbstractMethodDeclarationInterfaceMemberDeclaration(AOldAbstractMethodDeclarationInterfaceMemberDeclaration node)
02984     {
02985         inAOldAbstractMethodDeclarationInterfaceMemberDeclaration(node);
02986         if(node.getAbstractMethodDeclaration() != null)
02987         {
02988             node.getAbstractMethodDeclaration().apply(this);
02989         }
02990         outAOldAbstractMethodDeclarationInterfaceMemberDeclaration(node);
02991     }
02992     public void caseAOldArrayInitializer(AOldArrayInitializer node)
02993     {
02994         inAOldArrayInitializer(node);
02995         if(node.getRBrace() != null)
02996         {
02997             node.getRBrace().apply(this);
02998         }
02999         if(node.getComma() != null)
03000         {
03001             node.getComma().apply(this);
03002         }
03003         if(node.getVariableInitializers() != null)
03004         {
03005             node.getVariableInitializers().apply(this);
03006         }
03007         if(node.getLBrace() != null)
03008         {
03009             node.getLBrace().apply(this);
03010         }
03011         outAOldArrayInitializer(node);
03012     }
03013     public void caseAOldCaseSwitchLabel(AOldCaseSwitchLabel node)
03014     {
03015         inAOldCaseSwitchLabel(node);
03016         if(node.getColon() != null)
03017         {
03018             node.getColon().apply(this);
03019         }
03020         if(node.getConstantExp() != null)
03021         {
03022             node.getConstantExp().apply(this);
03023         }
03024         if(node.getCase() != null)
03025         {
03026             node.getCase().apply(this);
03027         }
03028         outAOldCaseSwitchLabel(node);
03029     }
03030     public void caseAOldCompilationUnit(AOldCompilationUnit node)
03031     {
03032         inAOldCompilationUnit(node);
03033         {
03034             Object temp[] = node.getTypeDeclaration().toArray();
03035             for(int i = temp.length - 1; i >= 0; i--)
03036             {
03037                 ((PTypeDeclaration) temp[i]).apply(this);
03038             }
03039         }
03040         {
03041             Object temp[] = node.getImportDeclaration().toArray();
03042             for(int i = temp.length - 1; i >= 0; i--)
03043             {
03044                 ((PImportDeclaration) temp[i]).apply(this);
03045             }
03046         }
03047         if(node.getPackageDeclaration() != null)
03048         {
03049             node.getPackageDeclaration().apply(this);
03050         }
03051         outAOldCompilationUnit(node);
03052     }
03053     public void caseAOldConstantDeclarationInterfaceMemberDeclaration(AOldConstantDeclarationInterfaceMemberDeclaration node)
03054     {
03055         inAOldConstantDeclarationInterfaceMemberDeclaration(node);
03056         if(node.getConstantDeclaration() != null)
03057         {
03058             node.getConstantDeclaration().apply(this);
03059         }
03060         outAOldConstantDeclarationInterfaceMemberDeclaration(node);
03061     }
03062     public void caseAOldConstructorDeclarator(AOldConstructorDeclarator node)
03063     {
03064         inAOldConstructorDeclarator(node);
03065         if(node.getRPar() != null)
03066         {
03067             node.getRPar().apply(this);
03068         }
03069         if(node.getFormalParameterList() != null)
03070         {
03071             node.getFormalParameterList().apply(this);
03072         }
03073         if(node.getLPar() != null)
03074         {
03075             node.getLPar().apply(this);
03076         }
03077         if(node.getId() != null)
03078         {
03079             node.getId().apply(this);
03080         }
03081         outAOldConstructorDeclarator(node);
03082     }
03083     public void caseAOldExp(AOldExp node)
03084     {
03085         inAOldExp(node);
03086         if(node.getAssignmentExp() != null)
03087         {
03088             node.getAssignmentExp().apply(this);
03089         }
03090         outAOldExp(node);
03091     }
03092     public void caseAOldExpCastExp(AOldExpCastExp node)
03093     {
03094         inAOldExpCastExp(node);
03095         if(node.getUnaryExpNotPlusMinus() != null)
03096         {
03097             node.getUnaryExpNotPlusMinus().apply(this);
03098         }
03099         if(node.getRPar() != null)
03100         {
03101             node.getRPar().apply(this);
03102         }
03103         if(node.getExp() != null)
03104         {
03105             node.getExp().apply(this);
03106         }
03107         if(node.getLPar() != null)
03108         {
03109             node.getLPar().apply(this);
03110         }
03111         outAOldExpCastExp(node);
03112     }
03113     public void caseAOldFieldDeclaration(AOldFieldDeclaration node)
03114     {
03115         inAOldFieldDeclaration(node);
03116         if(node.getSemicolon() != null)
03117         {
03118             node.getSemicolon().apply(this);
03119         }
03120         if(node.getVariableDeclarators() != null)
03121         {
03122             node.getVariableDeclarators().apply(this);
03123         }
03124         if(node.getType() != null)
03125         {
03126             node.getType().apply(this);
03127         }
03128         {
03129             Object temp[] = node.getModifier().toArray();
03130             for(int i = temp.length - 1; i >= 0; i--)
03131             {
03132                 ((PModifier) temp[i]).apply(this);
03133             }
03134         }
03135         outAOldFieldDeclaration(node);
03136     }
03137     public void caseAOldInterfaceDeclaration(AOldInterfaceDeclaration node)
03138     {
03139         inAOldInterfaceDeclaration(node);
03140         if(node.getInterfaceBody() != null)
03141         {
03142             node.getInterfaceBody().apply(this);
03143         }
03144         if(node.getExtendsInterfaces() != null)
03145         {
03146             node.getExtendsInterfaces().apply(this);
03147         }
03148         if(node.getId() != null)
03149         {
03150             node.getId().apply(this);
03151         }
03152         if(node.getInterface() != null)
03153         {
03154             node.getInterface().apply(this);
03155         }
03156         {
03157             Object temp[] = node.getModifier().toArray();
03158             for(int i = temp.length - 1; i >= 0; i--)
03159             {
03160                 ((PModifier) temp[i]).apply(this);
03161             }
03162         }
03163         outAOldInterfaceDeclaration(node);
03164     }
03165     public void caseAOldInterfaces(AOldInterfaces node)
03166     {
03167         inAOldInterfaces(node);
03168         if(node.getInterfaceTypeList() != null)
03169         {
03170             node.getInterfaceTypeList().apply(this);
03171         }
03172         if(node.getImplements() != null)
03173         {
03174             node.getImplements().apply(this);
03175         }
03176         outAOldInterfaces(node);
03177     }
03178     public void caseAOldLocalVariableDeclaration(AOldLocalVariableDeclaration node)
03179     {
03180         inAOldLocalVariableDeclaration(node);
03181         if(node.getVariableDeclarators() != null)
03182         {
03183             node.getVariableDeclarators().apply(this);
03184         }
03185         if(node.getType() != null)
03186         {
03187             node.getType().apply(this);
03188         }
03189         {
03190             Object temp[] = node.getModifier().toArray();
03191             for(int i = temp.length - 1; i >= 0; i--)
03192             {
03193                 ((PModifier) temp[i]).apply(this);
03194             }
03195         }
03196         outAOldLocalVariableDeclaration(node);
03197     }
03198     public void caseAOldMethodDeclarator(AOldMethodDeclarator node)
03199     {
03200         inAOldMethodDeclarator(node);
03201         {
03202             Object temp[] = node.getDim().toArray();
03203             for(int i = temp.length - 1; i >= 0; i--)
03204             {
03205                 ((PDim) temp[i]).apply(this);
03206             }
03207         }
03208         if(node.getRPar() != null)
03209         {
03210             node.getRPar().apply(this);
03211         }
03212         if(node.getFormalParameterList() != null)
03213         {
03214             node.getFormalParameterList().apply(this);
03215         }
03216         if(node.getLPar() != null)
03217         {
03218             node.getLPar().apply(this);
03219         }
03220         if(node.getId() != null)
03221         {
03222             node.getId().apply(this);
03223         }
03224         outAOldMethodDeclarator(node);
03225     }
03226     public void caseAOldNameCastExp(AOldNameCastExp node)
03227     {
03228         inAOldNameCastExp(node);
03229         if(node.getUnaryExpNotPlusMinus() != null)
03230         {
03231             node.getUnaryExpNotPlusMinus().apply(this);
03232         }
03233         if(node.getRPar() != null)
03234         {
03235             node.getRPar().apply(this);
03236         }
03237         {
03238             Object temp[] = node.getDim().toArray();
03239             for(int i = temp.length - 1; i >= 0; i--)
03240             {
03241                 ((PDim) temp[i]).apply(this);
03242             }
03243         }
03244         if(node.getName() != null)
03245         {
03246             node.getName().apply(this);
03247         }
03248         if(node.getLPar() != null)
03249         {
03250             node.getLPar().apply(this);
03251         }
03252         outAOldNameCastExp(node);
03253     }
03254     public void caseAOldNamedTypePrimaryNoNewArray(AOldNamedTypePrimaryNoNewArray node)
03255     {
03256         inAOldNamedTypePrimaryNoNewArray(node);
03257         if(node.getTClass() != null)
03258         {
03259             node.getTClass().apply(this);
03260         }
03261         if(node.getDot() != null)
03262         {
03263             node.getDot().apply(this);
03264         }
03265         {
03266             Object temp[] = node.getDim().toArray();
03267             for(int i = temp.length - 1; i >= 0; i--)
03268             {
03269                 ((PDim) temp[i]).apply(this);
03270             }
03271         }
03272         if(node.getName() != null)
03273         {
03274             node.getName().apply(this);
03275         }
03276         outAOldNamedTypePrimaryNoNewArray(node);
03277     }
03278     public void caseAOldPrimaryFieldAccess(AOldPrimaryFieldAccess node)
03279     {
03280         inAOldPrimaryFieldAccess(node);
03281         if(node.getId() != null)
03282         {
03283             node.getId().apply(this);
03284         }
03285         if(node.getDot() != null)
03286         {
03287             node.getDot().apply(this);
03288         }
03289         if(node.getPrimary() != null)
03290         {
03291             node.getPrimary().apply(this);
03292         }
03293         outAOldPrimaryFieldAccess(node);
03294     }
03295     public void caseAOldPrimaryNoNewArrayArrayAccess(AOldPrimaryNoNewArrayArrayAccess node)
03296     {
03297         inAOldPrimaryNoNewArrayArrayAccess(node);
03298         if(node.getRBracket() != null)
03299         {
03300             node.getRBracket().apply(this);
03301         }
03302         if(node.getExp() != null)
03303         {
03304             node.getExp().apply(this);
03305         }
03306         if(node.getLBracket() != null)
03307         {
03308             node.getLBracket().apply(this);
03309         }
03310         if(node.getPrimaryNoNewArray() != null)
03311         {
03312             node.getPrimaryNoNewArray().apply(this);
03313         }
03314         outAOldPrimaryNoNewArrayArrayAccess(node);
03315     }
03316     public void caseAOldPrimitiveTypeCastExp(AOldPrimitiveTypeCastExp node)
03317     {
03318         inAOldPrimitiveTypeCastExp(node);
03319         if(node.getUnaryExp() != null)
03320         {
03321             node.getUnaryExp().apply(this);
03322         }
03323         if(node.getRPar() != null)
03324         {
03325             node.getRPar().apply(this);
03326         }
03327         {
03328             Object temp[] = node.getDim().toArray();
03329             for(int i = temp.length - 1; i >= 0; i--)
03330             {
03331                 ((PDim) temp[i]).apply(this);
03332             }
03333         }
03334         if(node.getPrimitiveType() != null)
03335         {
03336             node.getPrimitiveType().apply(this);
03337         }
03338         if(node.getLPar() != null)
03339         {
03340             node.getLPar().apply(this);
03341         }
03342         outAOldPrimitiveTypeCastExp(node);
03343     }
03344     public void caseAOldPrimitiveTypePrimaryNoNewArray(AOldPrimitiveTypePrimaryNoNewArray node)
03345     {
03346         inAOldPrimitiveTypePrimaryNoNewArray(node);
03347         if(node.getTClass() != null)
03348         {
03349             node.getTClass().apply(this);
03350         }
03351         if(node.getDot() != null)
03352         {
03353             node.getDot().apply(this);
03354         }
03355         {
03356             Object temp[] = node.getDim().toArray();
03357             for(int i = temp.length - 1; i >= 0; i--)
03358             {
03359                 ((PDim) temp[i]).apply(this);
03360             }
03361         }
03362         if(node.getPrimitiveType() != null)
03363         {
03364             node.getPrimitiveType().apply(this);
03365         }
03366         outAOldPrimitiveTypePrimaryNoNewArray(node);
03367     }
03368     public void caseAOldQualifiedClassInstanceCreationExp(AOldQualifiedClassInstanceCreationExp node)
03369     {
03370         inAOldQualifiedClassInstanceCreationExp(node);
03371         if(node.getClassBody() != null)
03372         {
03373             node.getClassBody().apply(this);
03374         }
03375         if(node.getRPar() != null)
03376         {
03377             node.getRPar().apply(this);
03378         }
03379         if(node.getArgumentList() != null)
03380         {
03381             node.getArgumentList().apply(this);
03382         }
03383         if(node.getLPar() != null)
03384         {
03385             node.getLPar().apply(this);
03386         }
03387         if(node.getId() != null)
03388         {
03389             node.getId().apply(this);
03390         }
03391         if(node.getNew() != null)
03392         {
03393             node.getNew().apply(this);
03394         }
03395         if(node.getDot() != null)
03396         {
03397             node.getDot().apply(this);
03398         }
03399         if(node.getPrimary() != null)
03400         {
03401             node.getPrimary().apply(this);
03402         }
03403         outAOldQualifiedClassInstanceCreationExp(node);
03404     }
03405     public void caseAOldQualifiedConstructorInvocation(AOldQualifiedConstructorInvocation node)
03406     {
03407         inAOldQualifiedConstructorInvocation(node);
03408         if(node.getSemicolon() != null)
03409         {
03410             node.getSemicolon().apply(this);
03411         }
03412         if(node.getRPar() != null)
03413         {
03414             node.getRPar().apply(this);
03415         }
03416         if(node.getArgumentList() != null)
03417         {
03418             node.getArgumentList().apply(this);
03419         }
03420         if(node.getLPar() != null)
03421         {
03422             node.getLPar().apply(this);
03423         }
03424         if(node.getSuper() != null)
03425         {
03426             node.getSuper().apply(this);
03427         }
03428         if(node.getDot() != null)
03429         {
03430             node.getDot().apply(this);
03431         }
03432         if(node.getPrimary() != null)
03433         {
03434             node.getPrimary().apply(this);
03435         }
03436         outAOldQualifiedConstructorInvocation(node);
03437     }
03438     public void caseAOldSimpleClassInstanceCreationExp(AOldSimpleClassInstanceCreationExp node)
03439     {
03440         inAOldSimpleClassInstanceCreationExp(node);
03441         if(node.getClassBody() != null)
03442         {
03443             node.getClassBody().apply(this);
03444         }
03445         if(node.getRPar() != null)
03446         {
03447             node.getRPar().apply(this);
03448         }
03449         if(node.getArgumentList() != null)
03450         {
03451             node.getArgumentList().apply(this);
03452         }
03453         if(node.getLPar() != null)
03454         {
03455             node.getLPar().apply(this);
03456         }
03457         if(node.getName() != null)
03458         {
03459             node.getName().apply(this);
03460         }
03461         if(node.getNew() != null)
03462         {
03463             node.getNew().apply(this);
03464         }
03465         outAOldSimpleClassInstanceCreationExp(node);
03466     }
03467     public void caseAOldStaticInitializerClassBodyDeclaration(AOldStaticInitializerClassBodyDeclaration node)
03468     {
03469         inAOldStaticInitializerClassBodyDeclaration(node);
03470         if(node.getStaticInitializer() != null)
03471         {
03472             node.getStaticInitializer().apply(this);
03473         }
03474         outAOldStaticInitializerClassBodyDeclaration(node);
03475     }
03476     public void caseAOldSuper(AOldSuper node)
03477     {
03478         inAOldSuper(node);
03479         if(node.getClassType() != null)
03480         {
03481             node.getClassType().apply(this);
03482         }
03483         if(node.getExtends() != null)
03484         {
03485             node.getExtends().apply(this);
03486         }
03487         outAOldSuper(node);
03488     }
03489     public void caseAOldSuperConstructorInvocation(AOldSuperConstructorInvocation node)
03490     {
03491         inAOldSuperConstructorInvocation(node);
03492         if(node.getSemicolon() != null)
03493         {
03494             node.getSemicolon().apply(this);
03495         }
03496         if(node.getRPar() != null)
03497         {
03498             node.getRPar().apply(this);
03499         }
03500         if(node.getArgumentList() != null)
03501         {
03502             node.getArgumentList().apply(this);
03503         }
03504         if(node.getLPar() != null)
03505         {
03506             node.getLPar().apply(this);
03507         }
03508         if(node.getSuper() != null)
03509         {
03510             node.getSuper().apply(this);
03511         }
03512         outAOldSuperConstructorInvocation(node);
03513     }
03514     public void caseAOldThisConstructorInvocation(AOldThisConstructorInvocation node)
03515     {
03516         inAOldThisConstructorInvocation(node);
03517         if(node.getSemicolon() != null)
03518         {
03519             node.getSemicolon().apply(this);
03520         }
03521         if(node.getRPar() != null)
03522         {
03523             node.getRPar().apply(this);
03524         }
03525         if(node.getArgumentList() != null)
03526         {
03527             node.getArgumentList().apply(this);
03528         }
03529         if(node.getLPar() != null)
03530         {
03531             node.getLPar().apply(this);
03532         }
03533         if(node.getThis() != null)
03534         {
03535             node.getThis().apply(this);
03536         }
03537         outAOldThisConstructorInvocation(node);
03538     }
03539     public void caseAOldThrows(AOldThrows node)
03540     {
03541         inAOldThrows(node);
03542         if(node.getClassTypeList() != null)
03543         {
03544             node.getClassTypeList().apply(this);
03545         }
03546         if(node.getThrows() != null)
03547         {
03548             node.getThrows().apply(this);
03549         }
03550         outAOldThrows(node);
03551     }
03552     public void caseAOneBreakStmt(AOneBreakStmt node)
03553     {
03554         inAOneBreakStmt(node);
03555         if(node.getSemicolon() != null)
03556         {
03557             node.getSemicolon().apply(this);
03558         }
03559         if(node.getId() != null)
03560         {
03561             node.getId().apply(this);
03562         }
03563         if(node.getBreak() != null)
03564         {
03565             node.getBreak().apply(this);
03566         }
03567         outAOneBreakStmt(node);
03568     }
03569     public void caseAOneContinueStmt(AOneContinueStmt node)
03570     {
03571         inAOneContinueStmt(node);
03572         if(node.getSemicolon() != null)
03573         {
03574             node.getSemicolon().apply(this);
03575         }
03576         if(node.getId() != null)
03577         {
03578             node.getId().apply(this);
03579         }
03580         if(node.getContinue() != null)
03581         {
03582             node.getContinue().apply(this);
03583         }
03584         outAOneContinueStmt(node);
03585     }
03586     public void caseAOneDoStmt(AOneDoStmt node)
03587     {
03588         inAOneDoStmt(node);
03589         if(node.getSemicolon() != null)
03590         {
03591             node.getSemicolon().apply(this);
03592         }
03593         if(node.getRPar() != null)
03594         {
03595             node.getRPar().apply(this);
03596         }
03597         if(node.getExp() != null)
03598         {
03599             node.getExp().apply(this);
03600         }
03601         if(node.getLPar() != null)
03602         {
03603             node.getLPar().apply(this);
03604         }
03605         if(node.getWhile() != null)
03606         {
03607             node.getWhile().apply(this);
03608         }
03609         if(node.getStmt() != null)
03610         {
03611             node.getStmt().apply(this);
03612         }
03613         if(node.getDo() != null)
03614         {
03615             node.getDo().apply(this);
03616         }
03617         outAOneDoStmt(node);
03618     }
03619     public void caseAOneForStmt(AOneForStmt node)
03620     {
03621         inAOneForStmt(node);
03622         if(node.getStmt() != null)
03623         {
03624             node.getStmt().apply(this);
03625         }
03626         if(node.getRPar() != null)
03627         {
03628             node.getRPar().apply(this);
03629         }
03630         if(node.getForUpdate() != null)
03631         {
03632             node.getForUpdate().apply(this);
03633         }
03634         if(node.getSemicolon2() != null)
03635         {
03636             node.getSemicolon2().apply(this);
03637         }
03638         if(node.getExp() != null)
03639         {
03640             node.getExp().apply(this);
03641         }
03642         if(node.getSemicolon1() != null)
03643         {
03644             node.getSemicolon1().apply(this);
03645         }
03646         if(node.getForInit() != null)
03647         {
03648             node.getForInit().apply(this);
03649         }
03650         if(node.getLPar() != null)
03651         {
03652             node.getLPar().apply(this);
03653         }
03654         if(node.getFor() != null)
03655         {
03656             node.getFor().apply(this);
03657         }
03658         outAOneForStmt(node);
03659     }
03660     public void caseAOneQualifiedName(AOneQualifiedName node)
03661     {
03662         inAOneQualifiedName(node);
03663         if(node.getId() != null)
03664         {
03665             node.getId().apply(this);
03666         }
03667         if(node.getDot() != null)
03668         {
03669             node.getDot().apply(this);
03670         }
03671         if(node.getName() != null)
03672         {
03673             node.getName().apply(this);
03674         }
03675         outAOneQualifiedName(node);
03676     }
03677     public void caseAOneReturnStmt(AOneReturnStmt node)
03678     {
03679         inAOneReturnStmt(node);
03680         if(node.getSemicolon() != null)
03681         {
03682             node.getSemicolon().apply(this);
03683         }
03684         if(node.getExp() != null)
03685         {
03686             node.getExp().apply(this);
03687         }
03688         if(node.getReturn() != null)
03689         {
03690             node.getReturn().apply(this);
03691         }
03692         outAOneReturnStmt(node);
03693     }
03694     public void caseAOneSimpleName(AOneSimpleName node)
03695     {
03696         inAOneSimpleName(node);
03697         if(node.getId() != null)
03698         {
03699             node.getId().apply(this);
03700         }
03701         outAOneSimpleName(node);
03702     }
03703     public void caseAOneSingleTypeImportDeclaration(AOneSingleTypeImportDeclaration node)
03704     {
03705         inAOneSingleTypeImportDeclaration(node);
03706         if(node.getSemicolon() != null)
03707         {
03708             node.getSemicolon().apply(this);
03709         }
03710         if(node.getName() != null)
03711         {
03712             node.getName().apply(this);
03713         }
03714         if(node.getImport() != null)
03715         {
03716             node.getImport().apply(this);
03717         }
03718         outAOneSingleTypeImportDeclaration(node);
03719     }
03720     public void caseAOneSwitchStmt(AOneSwitchStmt node)
03721     {
03722         inAOneSwitchStmt(node);
03723         if(node.getRBrace() != null)
03724         {
03725             node.getRBrace().apply(this);
03726         }
03727         {
03728             Object temp[] = node.getSwitchLabel().toArray();
03729             for(int i = temp.length - 1; i >= 0; i--)
03730             {
03731                 ((PSwitchLabel) temp[i]).apply(this);
03732             }
03733         }
03734         {
03735             Object temp[] = node.getSwitchBlockStmtGroup().toArray();
03736             for(int i = temp.length - 1; i >= 0; i--)
03737             {
03738                 ((PSwitchBlockStmtGroup) temp[i]).apply(this);
03739             }
03740         }
03741         if(node.getLBrace() != null)
03742         {
03743             node.getLBrace().apply(this);
03744         }
03745         if(node.getRPar() != null)
03746         {
03747             node.getRPar().apply(this);
03748         }
03749         if(node.getExp() != null)
03750         {
03751             node.getExp().apply(this);
03752         }
03753         if(node.getLPar() != null)
03754         {
03755             node.getLPar().apply(this);
03756         }
03757         if(node.getSwitch() != null)
03758         {
03759             node.getSwitch().apply(this);
03760         }
03761         outAOneSwitchStmt(node);
03762     }
03763     public void caseAOneSynchronizedStmt(AOneSynchronizedStmt node)
03764     {
03765         inAOneSynchronizedStmt(node);
03766         if(node.getBlock() != null)
03767         {
03768             node.getBlock().apply(this);
03769         }
03770         if(node.getRPar() != null)
03771         {
03772             node.getRPar().apply(this);
03773         }
03774         if(node.getExp() != null)
03775         {
03776             node.getExp().apply(this);
03777         }
03778         if(node.getLPar() != null)
03779         {
03780             node.getLPar().apply(this);
03781         }
03782         if(node.getSynchronized() != null)
03783         {
03784             node.getSynchronized().apply(this);
03785         }
03786         outAOneSynchronizedStmt(node);
03787     }
03788     public void caseAOneThrowStmt(AOneThrowStmt node)
03789     {
03790         inAOneThrowStmt(node);
03791         if(node.getSemicolon() != null)
03792         {
03793             node.getSemicolon().apply(this);
03794         }
03795         if(node.getExp() != null)
03796         {
03797             node.getExp().apply(this);
03798         }
03799         if(node.getThrow() != null)
03800         {
03801             node.getThrow().apply(this);
03802         }
03803         outAOneThrowStmt(node);
03804     }
03805     public void caseAOneTypeImportOnDemandDeclaration(AOneTypeImportOnDemandDeclaration node)
03806     {
03807         inAOneTypeImportOnDemandDeclaration(node);
03808         if(node.getSemicolon() != null)
03809         {
03810             node.getSemicolon().apply(this);
03811         }
03812         if(node.getStar() != null)
03813         {
03814             node.getStar().apply(this);
03815         }
03816         if(node.getDot() != null)
03817         {
03818             node.getDot().apply(this);
03819         }
03820         if(node.getName() != null)
03821         {
03822             node.getName().apply(this);
03823         }
03824         if(node.getImport() != null)
03825         {
03826             node.getImport().apply(this);
03827         }
03828         outAOneTypeImportOnDemandDeclaration(node);
03829     }
03830     public void caseAOneWhileStmt(AOneWhileStmt node)
03831     {
03832         inAOneWhileStmt(node);
03833         if(node.getStmt() != null)
03834         {
03835             node.getStmt().apply(this);
03836         }
03837         if(node.getRPar() != null)
03838         {
03839             node.getRPar().apply(this);
03840         }
03841         if(node.getExp() != null)
03842         {
03843             node.getExp().apply(this);
03844         }
03845         if(node.getLPar() != null)
03846         {
03847             node.getLPar().apply(this);
03848         }
03849         if(node.getWhile() != null)
03850         {
03851             node.getWhile().apply(this);
03852         }
03853         outAOneWhileStmt(node);
03854     }
03855     public void caseAOrBinaryOperator(AOrBinaryOperator node)
03856     {
03857         inAOrBinaryOperator(node);
03858         if(node.getOr() != null)
03859         {
03860             node.getOr().apply(this);
03861         }
03862         outAOrBinaryOperator(node);
03863     }
03864     public void caseAOriginalExpStmt(AOriginalExpStmt node)
03865     {
03866         inAOriginalExpStmt(node);
03867         if(node.getSemicolon() != null)
03868         {
03869             node.getSemicolon().apply(this);
03870         }
03871         if(node.getStmtExp() != null)
03872         {
03873             node.getStmtExp().apply(this);
03874         }
03875         outAOriginalExpStmt(node);
03876     }
03877     public void caseAPackageDeclaration(APackageDeclaration node)
03878     {
03879         inAPackageDeclaration(node);
03880         if(node.getSemicolon() != null)
03881         {
03882             node.getSemicolon().apply(this);
03883         }
03884         if(node.getName() != null)
03885         {
03886             node.getName().apply(this);
03887         }
03888         if(node.getPackage() != null)
03889         {
03890             node.getPackage().apply(this);
03891         }
03892         outAPackageDeclaration(node);
03893     }
03894     public void caseAParExp(AParExp node)
03895     {
03896         inAParExp(node);
03897         if(node.getRPar() != null)
03898         {
03899             node.getRPar().apply(this);
03900         }
03901         if(node.getExp() != null)
03902         {
03903             node.getExp().apply(this);
03904         }
03905         if(node.getLPar() != null)
03906         {
03907             node.getLPar().apply(this);
03908         }
03909         outAParExp(node);
03910     }
03911     public void caseAPlusAdditiveExp(APlusAdditiveExp node)
03912     {
03913         inAPlusAdditiveExp(node);
03914         if(node.getMultiplicativeExp() != null)
03915         {
03916             node.getMultiplicativeExp().apply(this);
03917         }
03918         if(node.getPlus() != null)
03919         {
03920             node.getPlus().apply(this);
03921         }
03922         if(node.getAdditiveExp() != null)
03923         {
03924             node.getAdditiveExp().apply(this);
03925         }
03926         outAPlusAdditiveExp(node);
03927     }
03928     public void caseAPlusAssignAssignmentOperator(APlusAssignAssignmentOperator node)
03929     {
03930         inAPlusAssignAssignmentOperator(node);
03931         if(node.getPlusAssign() != null)
03932         {
03933             node.getPlusAssign().apply(this);
03934         }
03935         outAPlusAssignAssignmentOperator(node);
03936     }
03937     public void caseAPlusBinaryOperator(APlusBinaryOperator node)
03938     {
03939         inAPlusBinaryOperator(node);
03940         if(node.getPlus() != null)
03941         {
03942             node.getPlus().apply(this);
03943         }
03944         outAPlusBinaryOperator(node);
03945     }
03946     public void caseAPlusUnaryExp(APlusUnaryExp node)
03947     {
03948         inAPlusUnaryExp(node);
03949         if(node.getUnaryExp() != null)
03950         {
03951             node.getUnaryExp().apply(this);
03952         }
03953         if(node.getPlus() != null)
03954         {
03955             node.getPlus().apply(this);
03956         }
03957         outAPlusUnaryExp(node);
03958     }
03959     public void caseAPlusUnaryOperator(APlusUnaryOperator node)
03960     {
03961         inAPlusUnaryOperator(node);
03962         if(node.getPlus() != null)
03963         {
03964             node.getPlus().apply(this);
03965         }
03966         outAPlusUnaryOperator(node);
03967     }
03968     public void caseAPostDecrementExp(APostDecrementExp node)
03969     {
03970         inAPostDecrementExp(node);
03971         if(node.getMinusMinus() != null)
03972         {
03973             node.getMinusMinus().apply(this);
03974         }
03975         if(node.getExp() != null)
03976         {
03977             node.getExp().apply(this);
03978         }
03979         outAPostDecrementExp(node);
03980     }
03981     public void caseAPostDecrementExpPostfixExp(APostDecrementExpPostfixExp node)
03982     {
03983         inAPostDecrementExpPostfixExp(node);
03984         if(node.getPostDecrementExpr() != null)
03985         {
03986             node.getPostDecrementExpr().apply(this);
03987         }
03988         outAPostDecrementExpPostfixExp(node);
03989     }
03990     public void caseAPostDecrementExpr(APostDecrementExpr node)
03991     {
03992         inAPostDecrementExpr(node);
03993         if(node.getMinusMinus() != null)
03994         {
03995             node.getMinusMinus().apply(this);
03996         }
03997         if(node.getPostfixExp() != null)
03998         {
03999             node.getPostfixExp().apply(this);
04000         }
04001         outAPostDecrementExpr(node);
04002     }
04003     public void caseAPostDecrementExpStmtExp(APostDecrementExpStmtExp node)
04004     {
04005         inAPostDecrementExpStmtExp(node);
04006         if(node.getPostDecrementExpr() != null)
04007         {
04008             node.getPostDecrementExpr().apply(this);
04009         }
04010         outAPostDecrementExpStmtExp(node);
04011     }
04012     public void caseAPostfixExpUnaryExpNotPlusMinus(APostfixExpUnaryExpNotPlusMinus node)
04013     {
04014         inAPostfixExpUnaryExpNotPlusMinus(node);
04015         if(node.getPostfixExp() != null)
04016         {
04017             node.getPostfixExp().apply(this);
04018         }
04019         outAPostfixExpUnaryExpNotPlusMinus(node);
04020     }
04021     public void caseAPostIncrementExp(APostIncrementExp node)
04022     {
04023         inAPostIncrementExp(node);
04024         if(node.getPlusPlus() != null)
04025         {
04026             node.getPlusPlus().apply(this);
04027         }
04028         if(node.getExp() != null)
04029         {
04030             node.getExp().apply(this);
04031         }
04032         outAPostIncrementExp(node);
04033     }
04034     public void caseAPostIncrementExpPostfixExp(APostIncrementExpPostfixExp node)
04035     {
04036         inAPostIncrementExpPostfixExp(node);
04037         if(node.getPostIncrementExpr() != null)
04038         {
04039             node.getPostIncrementExpr().apply(this);
04040         }
04041         outAPostIncrementExpPostfixExp(node);
04042     }
04043     public void caseAPostIncrementExpr(APostIncrementExpr node)
04044     {
04045         inAPostIncrementExpr(node);
04046         if(node.getPlusPlus() != null)
04047         {
04048             node.getPlusPlus().apply(this);
04049         }
04050         if(node.getPostfixExp() != null)
04051         {
04052             node.getPostfixExp().apply(this);
04053         }
04054         outAPostIncrementExpr(node);
04055     }
04056     public void caseAPostIncrementExpStmtExp(APostIncrementExpStmtExp node)
04057     {
04058         inAPostIncrementExpStmtExp(node);
04059         if(node.getPostIncrementExpr() != null)
04060         {
04061             node.getPostIncrementExpr().apply(this);
04062         }
04063         outAPostIncrementExpStmtExp(node);
04064     }
04065     public void caseAPreDecrementExp(APreDecrementExp node)
04066     {
04067         inAPreDecrementExp(node);
04068         if(node.getUnaryExp() != null)
04069         {
04070             node.getUnaryExp().apply(this);
04071         }
04072         if(node.getMinusMinus() != null)
04073         {
04074             node.getMinusMinus().apply(this);
04075         }
04076         outAPreDecrementExp(node);
04077     }
04078     public void caseAPreDecrementExpStmtExp(APreDecrementExpStmtExp node)
04079     {
04080         inAPreDecrementExpStmtExp(node);
04081         if(node.getPreDecrementExp() != null)
04082         {
04083             node.getPreDecrementExp().apply(this);
04084         }
04085         outAPreDecrementExpStmtExp(node);
04086     }
04087     public void caseAPreDecrementExpUnaryExp(APreDecrementExpUnaryExp node)
04088     {
04089         inAPreDecrementExpUnaryExp(node);
04090         if(node.getPreDecrementExp() != null)
04091         {
04092             node.getPreDecrementExp().apply(this);
04093         }
04094         outAPreDecrementExpUnaryExp(node);
04095     }
04096     public void caseAPreIncrementExp(APreIncrementExp node)
04097     {
04098         inAPreIncrementExp(node);
04099         if(node.getUnaryExp() != null)
04100         {
04101             node.getUnaryExp().apply(this);
04102         }
04103         if(node.getPlusPlus() != null)
04104         {
04105             node.getPlusPlus().apply(this);
04106         }
04107         outAPreIncrementExp(node);
04108     }
04109     public void caseAPreIncrementExpStmtExp(APreIncrementExpStmtExp node)
04110     {
04111         inAPreIncrementExpStmtExp(node);
04112         if(node.getPreIncrementExp() != null)
04113         {
04114             node.getPreIncrementExp().apply(this);
04115         }
04116         outAPreIncrementExpStmtExp(node);
04117     }
04118     public void caseAPreIncrementExpUnaryExp(APreIncrementExpUnaryExp node)
04119     {
04120         inAPreIncrementExpUnaryExp(node);
04121         if(node.getPreIncrementExp() != null)
04122         {
04123             node.getPreIncrementExp().apply(this);
04124         }
04125         outAPreIncrementExpUnaryExp(node);
04126     }
04127     public void caseAPrimaryFieldAccess(APrimaryFieldAccess node)
04128     {
04129         inAPrimaryFieldAccess(node);
04130         if(node.getId() != null)
04131         {
04132             node.getId().apply(this);
04133         }
04134         if(node.getDot() != null)
04135         {
04136             node.getDot().apply(this);
04137         }
04138         if(node.getExp() != null)
04139         {
04140             node.getExp().apply(this);
04141         }
04142         outAPrimaryFieldAccess(node);
04143     }
04144     public void caseAPrimaryMethodInvocation(APrimaryMethodInvocation node)
04145     {
04146         inAPrimaryMethodInvocation(node);
04147         if(node.getRPar() != null)
04148         {
04149             node.getRPar().apply(this);
04150         }
04151         if(node.getArgumentList() != null)
04152         {
04153             node.getArgumentList().apply(this);
04154         }
04155         if(node.getLPar() != null)
04156         {
04157             node.getLPar().apply(this);
04158         }
04159         if(node.getId() != null)
04160         {
04161             node.getId().apply(this);
04162         }
04163         if(node.getDot() != null)
04164         {
04165             node.getDot().apply(this);
04166         }
04167         if(node.getPrimary() != null)
04168         {
04169             node.getPrimary().apply(this);
04170         }
04171         outAPrimaryMethodInvocation(node);
04172     }
04173     public void caseAPrimaryMethodInvocationExp(APrimaryMethodInvocationExp node)
04174     {
04175         inAPrimaryMethodInvocationExp(node);
04176         if(node.getRPar() != null)
04177         {
04178             node.getRPar().apply(this);
04179         }
04180         {
04181             Object temp[] = node.getArgumentList().toArray();
04182             for(int i = temp.length - 1; i >= 0; i--)
04183             {
04184                 ((PExp) temp[i]).apply(this);
04185             }
04186         }
04187         if(node.getLPar() != null)
04188         {
04189             node.getLPar().apply(this);
04190         }
04191         if(node.getId() != null)
04192         {
04193             node.getId().apply(this);
04194         }
04195         if(node.getDot() != null)
04196         {
04197             node.getDot().apply(this);
04198         }
04199         if(node.getExp() != null)
04200         {
04201             node.getExp().apply(this);
04202         }
04203         outAPrimaryMethodInvocationExp(node);
04204     }
04205     public void caseAPrimaryNoNewArrayArrayAccess(APrimaryNoNewArrayArrayAccess node)
04206     {
04207         inAPrimaryNoNewArrayArrayAccess(node);
04208         if(node.getRBracket() != null)
04209         {
04210             node.getRBracket().apply(this);
04211         }
04212         if(node.getSecond() != null)
04213         {
04214             node.getSecond().apply(this);
04215         }
04216         if(node.getLBracket() != null)
04217         {
04218             node.getLBracket().apply(this);
04219         }
04220         if(node.getFirst() != null)
04221         {
04222             node.getFirst().apply(this);
04223         }
04224         outAPrimaryNoNewArrayArrayAccess(node);
04225     }
04226     public void caseAPrimaryNoNewArrayPrimary(APrimaryNoNewArrayPrimary node)
04227     {
04228         inAPrimaryNoNewArrayPrimary(node);
04229         if(node.getPrimaryNoNewArray() != null)
04230         {
04231             node.getPrimaryNoNewArray().apply(this);
04232         }
04233         outAPrimaryNoNewArrayPrimary(node);
04234     }
04235     public void caseAPrimaryPostfixExp(APrimaryPostfixExp node)
04236     {
04237         inAPrimaryPostfixExp(node);
04238         if(node.getPrimary() != null)
04239         {
04240             node.getPrimary().apply(this);
04241         }
04242         outAPrimaryPostfixExp(node);
04243     }
04244     public void caseAPrimitiveArrayType(APrimitiveArrayType node)
04245     {
04246         inAPrimitiveArrayType(node);
04247         {
04248             Object temp[] = node.getDim().toArray();
04249             for(int i = temp.length - 1; i >= 0; i--)
04250             {
04251                 ((PDim) temp[i]).apply(this);
04252             }
04253         }
04254         if(node.getPrimitiveType() != null)
04255         {
04256             node.getPrimitiveType().apply(this);
04257         }
04258         outAPrimitiveArrayType(node);
04259     }
04260     public void caseAPrimitiveType(APrimitiveType node)
04261     {
04262         inAPrimitiveType(node);
04263         if(node.getPrimitiveType() != null)
04264         {
04265             node.getPrimitiveType().apply(this);
04266         }
04267         outAPrimitiveType(node);
04268     }
04269     public void caseAPrimitiveTypeArrayCreationExp(APrimitiveTypeArrayCreationExp node)
04270     {
04271         inAPrimitiveTypeArrayCreationExp(node);
04272         {
04273             Object temp[] = node.getDim().toArray();
04274             for(int i = temp.length - 1; i >= 0; i--)
04275             {
04276                 ((PDim) temp[i]).apply(this);
04277             }
04278         }
04279         {
04280             Object temp[] = node.getDimExp().toArray();
04281             for(int i = temp.length - 1; i >= 0; i--)
04282             {
04283                 ((PDimExp) temp[i]).apply(this);
04284             }
04285         }
04286         if(node.getPrimitiveType() != null)
04287         {
04288             node.getPrimitiveType().apply(this);
04289         }
04290         if(node.getNew() != null)
04291         {
04292             node.getNew().apply(this);
04293         }
04294         outAPrimitiveTypeArrayCreationExp(node);
04295     }
04296     public void caseAPrimitiveTypeArrayExp(APrimitiveTypeArrayExp node)
04297     {
04298         inAPrimitiveTypeArrayExp(node);
04299         {
04300             Object temp[] = node.getDim().toArray();
04301             for(int i = temp.length - 1; i >= 0; i--)
04302             {
04303                 ((PDim) temp[i]).apply(this);
04304             }
04305         }
04306         {
04307             Object temp[] = node.getDimExp().toArray();
04308             for(int i = temp.length - 1; i >= 0; i--)
04309             {
04310                 ((PDimExp) temp[i]).apply(this);
04311             }
04312         }
04313         if(node.getPrimitiveType() != null)
04314         {
04315             node.getPrimitiveType().apply(this);
04316         }
04317         if(node.getNew() != null)
04318         {
04319             node.getNew().apply(this);
04320         }
04321         outAPrimitiveTypeArrayExp(node);
04322     }
04323     public void caseAPrimitiveTypeCastExp(APrimitiveTypeCastExp node)
04324     {
04325         inAPrimitiveTypeCastExp(node);
04326         if(node.getExp() != null)
04327         {
04328             node.getExp().apply(this);
04329         }
04330         if(node.getRPar() != null)
04331         {
04332             node.getRPar().apply(this);
04333         }
04334         {
04335             Object temp[] = node.getDim().toArray();
04336             for(int i = temp.length - 1; i >= 0; i--)
04337             {
04338                 ((PDim) temp[i]).apply(this);
04339             }
04340         }
04341         if(node.getPrimitiveType() != null)
04342         {
04343             node.getPrimitiveType().apply(this);
04344         }
04345         if(node.getLPar() != null)
04346         {
04347             node.getLPar().apply(this);
04348         }
04349         outAPrimitiveTypeCastExp(node);
04350     }
04351     public void caseAPrimitiveTypePrimaryExp(APrimitiveTypePrimaryExp node)
04352     {
04353         inAPrimitiveTypePrimaryExp(node);
04354         if(node.getTClass() != null)
04355         {
04356             node.getTClass().apply(this);
04357         }
04358         if(node.getDot() != null)
04359         {
04360             node.getDot().apply(this);
04361         }
04362         {
04363             Object temp[] = node.getDim().toArray();
04364             for(int i = temp.length - 1; i >= 0; i--)
04365             {
04366                 ((PDim) temp[i]).apply(this);
04367             }
04368         }
04369         if(node.getPrimitiveType() != null)
04370         {
04371             node.getPrimitiveType().apply(this);
04372         }
04373         outAPrimitiveTypePrimaryExp(node);
04374     }
04375     public void caseAPrivateModifier(APrivateModifier node)
04376     {
04377         inAPrivateModifier(node);
04378         if(node.getPrivate() != null)
04379         {
04380             node.getPrivate().apply(this);
04381         }
04382         outAPrivateModifier(node);
04383     }
04384     public void caseAProtectedModifier(AProtectedModifier node)
04385     {
04386         inAProtectedModifier(node);
04387         if(node.getProtected() != null)
04388         {
04389             node.getProtected().apply(this);
04390         }
04391         outAProtectedModifier(node);
04392     }
04393     public void caseAPublicModifier(APublicModifier node)
04394     {
04395         inAPublicModifier(node);
04396         if(node.getPublic() != null)
04397         {
04398             node.getPublic().apply(this);
04399         }
04400         outAPublicModifier(node);
04401     }
04402     public void caseAQualifiedClassInstanceCreationExp(AQualifiedClassInstanceCreationExp node)
04403     {
04404         inAQualifiedClassInstanceCreationExp(node);
04405         if(node.getClassBody() != null)
04406         {
04407             node.getClassBody().apply(this);
04408         }
04409         if(node.getRPar() != null)
04410         {
04411             node.getRPar().apply(this);
04412         }
04413         {
04414             Object temp[] = node.getArgumentList().toArray();
04415             for(int i = temp.length - 1; i >= 0; i--)
04416             {
04417                 ((PExp) temp[i]).apply(this);
04418             }
04419         }
04420         if(node.getLPar() != null)
04421         {
04422             node.getLPar().apply(this);
04423         }
04424         if(node.getId() != null)
04425         {
04426             node.getId().apply(this);
04427         }
04428         if(node.getNew() != null)
04429         {
04430             node.getNew().apply(this);
04431         }
04432         if(node.getDot() != null)
04433         {
04434             node.getDot().apply(this);
04435         }
04436         if(node.getExp() != null)
04437         {
04438             node.getExp().apply(this);
04439         }
04440         outAQualifiedClassInstanceCreationExp(node);
04441     }
04442     public void caseAQualifiedConstructorInvocation(AQualifiedConstructorInvocation node)
04443     {
04444         inAQualifiedConstructorInvocation(node);
04445         if(node.getSemicolon() != null)
04446         {
04447             node.getSemicolon().apply(this);
04448         }
04449         if(node.getRPar() != null)
04450         {
04451             node.getRPar().apply(this);
04452         }
04453         {
04454             Object temp[] = node.getArgumentList().toArray();
04455             for(int i = temp.length - 1; i >= 0; i--)
04456             {
04457                 ((PExp) temp[i]).apply(this);
04458             }
04459         }
04460         if(node.getLPar() != null)
04461         {
04462             node.getLPar().apply(this);
04463         }
04464         if(node.getSuper() != null)
04465         {
04466             node.getSuper().apply(this);
04467         }
04468         if(node.getDot() != null)
04469         {
04470             node.getDot().apply(this);
04471         }
04472         if(node.getExp() != null)
04473         {
04474             node.getExp().apply(this);
04475         }
04476         outAQualifiedConstructorInvocation(node);
04477     }
04478     public void caseAQualifiedName(AQualifiedName node)
04479     {
04480         inAQualifiedName(node);
04481         if(node.getId() != null)
04482         {
04483             node.getId().apply(this);
04484         }
04485         if(node.getDot() != null)
04486         {
04487             node.getDot().apply(this);
04488         }
04489         if(node.getName() != null)
04490         {
04491             node.getName().apply(this);
04492         }
04493         outAQualifiedName(node);
04494     }
04495     public void caseAQualifiedNameName(AQualifiedNameName node)
04496     {
04497         inAQualifiedNameName(node);
04498         if(node.getOneQualifiedName() != null)
04499         {
04500             node.getOneQualifiedName().apply(this);
04501         }
04502         outAQualifiedNameName(node);
04503     }
04504     public void caseAQualifiedThisExp(AQualifiedThisExp node)
04505     {
04506         inAQualifiedThisExp(node);
04507         if(node.getThis() != null)
04508         {
04509             node.getThis().apply(this);
04510         }
04511         if(node.getDot() != null)
04512         {
04513             node.getDot().apply(this);
04514         }
04515         if(node.getName() != null)
04516         {
04517             node.getName().apply(this);
04518         }
04519         outAQualifiedThisExp(node);
04520     }
04521     public void caseAQualifiedThisPrimaryNoNewArray(AQualifiedThisPrimaryNoNewArray node)
04522     {
04523         inAQualifiedThisPrimaryNoNewArray(node);
04524         if(node.getThis() != null)
04525         {
04526             node.getThis().apply(this);
04527         }
04528         if(node.getDot() != null)
04529         {
04530             node.getDot().apply(this);
04531         }
04532         if(node.getName() != null)
04533         {
04534             node.getName().apply(this);
04535         }
04536         outAQualifiedThisPrimaryNoNewArray(node);
04537     }
04538     public void caseAQuestionConditionalExp(AQuestionConditionalExp node)
04539     {
04540         inAQuestionConditionalExp(node);
04541         if(node.getConditionalExp() != null)
04542         {
04543             node.getConditionalExp().apply(this);
04544         }
04545         if(node.getColon() != null)
04546         {
04547             node.getColon().apply(this);
04548         }
04549         if(node.getExp() != null)
04550         {
04551             node.getExp().apply(this);
04552         }
04553         if(node.getQuestion() != null)
04554         {
04555             node.getQuestion().apply(this);
04556         }
04557         if(node.getConditionalOrExp() != null)
04558         {
04559             node.getConditionalOrExp().apply(this);
04560         }
04561         outAQuestionConditionalExp(node);
04562     }
04563     public void caseAQuestionExp(AQuestionExp node)
04564     {
04565         inAQuestionExp(node);
04566         if(node.getThird() != null)
04567         {
04568             node.getThird().apply(this);
04569         }
04570         if(node.getColon() != null)
04571         {
04572             node.getColon().apply(this);
04573         }
04574         if(node.getSecond() != null)
04575         {
04576             node.getSecond().apply(this);
04577         }
04578         if(node.getQuestion() != null)
04579         {
04580             node.getQuestion().apply(this);
04581         }
04582         if(node.getFirst() != null)
04583         {
04584             node.getFirst().apply(this);
04585         }
04586         outAQuestionExp(node);
04587     }
04588     public void caseAReferenceType(AReferenceType node)
04589     {
04590         inAReferenceType(node);
04591         if(node.getReferenceType() != null)
04592         {
04593             node.getReferenceType().apply(this);
04594         }
04595         outAReferenceType(node);
04596     }
04597     public void caseARelationalExpEqualityExp(ARelationalExpEqualityExp node)
04598     {
04599         inARelationalExpEqualityExp(node);
04600         if(node.getRelationalExp() != null)
04601         {
04602             node.getRelationalExp().apply(this);
04603         }
04604         outARelationalExpEqualityExp(node);
04605     }
04606     public void caseAReturnStmt(AReturnStmt node)
04607     {
04608         inAReturnStmt(node);
04609         if(node.getSemicolon() != null)
04610         {
04611             node.getSemicolon().apply(this);
04612         }
04613         if(node.getExp() != null)
04614         {
04615             node.getExp().apply(this);
04616         }
04617         if(node.getReturn() != null)
04618         {
04619             node.getReturn().apply(this);
04620         }
04621         outAReturnStmt(node);
04622     }
04623     public void caseAReturnStmtStmtWithoutTrailingSubstmt(AReturnStmtStmtWithoutTrailingSubstmt node)
04624     {
04625         inAReturnStmtStmtWithoutTrailingSubstmt(node);
04626         if(node.getOneReturnStmt() != null)
04627         {
04628             node.getOneReturnStmt().apply(this);
04629         }
04630         outAReturnStmtStmtWithoutTrailingSubstmt(node);
04631     }
04632     public void caseASemicolonStmt(ASemicolonStmt node)
04633     {
04634         inASemicolonStmt(node);
04635         if(node.getSemicolon() != null)
04636         {
04637             node.getSemicolon().apply(this);
04638         }
04639         outASemicolonStmt(node);
04640     }
04641     public void caseAShiftExpRelationalExp(AShiftExpRelationalExp node)
04642     {
04643         inAShiftExpRelationalExp(node);
04644         if(node.getShiftExp() != null)
04645         {
04646             node.getShiftExp().apply(this);
04647         }
04648         outAShiftExpRelationalExp(node);
04649     }
04650     public void caseAShiftLeftAssignAssignmentOperator(AShiftLeftAssignAssignmentOperator node)
04651     {
04652         inAShiftLeftAssignAssignmentOperator(node);
04653         if(node.getShiftLeftAssign() != null)
04654         {
04655             node.getShiftLeftAssign().apply(this);
04656         }
04657         outAShiftLeftAssignAssignmentOperator(node);
04658     }
04659     public void caseAShiftLeftBinaryOperator(AShiftLeftBinaryOperator node)
04660     {
04661         inAShiftLeftBinaryOperator(node);
04662         if(node.getShiftLeft() != null)
04663         {
04664             node.getShiftLeft().apply(this);
04665         }
04666         outAShiftLeftBinaryOperator(node);
04667     }
04668     public void caseAShiftLeftShiftExp(AShiftLeftShiftExp node)
04669     {
04670         inAShiftLeftShiftExp(node);
04671         if(node.getAdditiveExp() != null)
04672         {
04673             node.getAdditiveExp().apply(this);
04674         }
04675         if(node.getShiftLeft() != null)
04676         {
04677             node.getShiftLeft().apply(this);
04678         }
04679         if(node.getShiftExp() != null)
04680         {
04681             node.getShiftExp().apply(this);
04682         }
04683         outAShiftLeftShiftExp(node);
04684     }
04685     public void caseAShortIntegralType(AShortIntegralType node)
04686     {
04687         inAShortIntegralType(node);
04688         if(node.getShort() != null)
04689         {
04690             node.getShort().apply(this);
04691         }
04692         outAShortIntegralType(node);
04693     }
04694     public void caseAShortPrimitiveType(AShortPrimitiveType node)
04695     {
04696         inAShortPrimitiveType(node);
04697         if(node.getShort() != null)
04698         {
04699             node.getShort().apply(this);
04700         }
04701         outAShortPrimitiveType(node);
04702     }
04703     public void caseASignedShiftRightAssignAssignmentOperator(ASignedShiftRightAssignAssignmentOperator node)
04704     {
04705         inASignedShiftRightAssignAssignmentOperator(node);
04706         if(node.getSignedShiftRightAssign() != null)
04707         {
04708             node.getSignedShiftRightAssign().apply(this);
04709         }
04710         outASignedShiftRightAssignAssignmentOperator(node);
04711     }
04712     public void caseASignedShiftRightBinaryOperator(ASignedShiftRightBinaryOperator node)
04713     {
04714         inASignedShiftRightBinaryOperator(node);
04715         if(node.getSignedShiftRight() != null)
04716         {
04717             node.getSignedShiftRight().apply(this);
04718         }
04719         outASignedShiftRightBinaryOperator(node);
04720     }
04721     public void caseASignedShiftRightShiftExp(ASignedShiftRightShiftExp node)
04722     {
04723         inASignedShiftRightShiftExp(node);
04724         if(node.getAdditiveExp() != null)
04725         {
04726             node.getAdditiveExp().apply(this);
04727         }
04728         if(node.getSignedShiftRight() != null)
04729         {
04730             node.getSignedShiftRight().apply(this);
04731         }
04732         if(node.getShiftExp() != null)
04733         {
04734             node.getShiftExp().apply(this);
04735         }
04736         outASignedShiftRightShiftExp(node);
04737     }
04738     public void caseASimpleClassInstanceCreationExp(ASimpleClassInstanceCreationExp node)
04739     {
04740         inASimpleClassInstanceCreationExp(node);
04741         if(node.getClassBody() != null)
04742         {
04743             node.getClassBody().apply(this);
04744         }
04745         if(node.getRPar() != null)
04746         {
04747             node.getRPar().apply(this);
04748         }
04749         {
04750             Object temp[] = node.getArgumentList().toArray();
04751             for(int i = temp.length - 1; i >= 0; i--)
04752             {
04753                 ((PExp) temp[i]).apply(this);
04754             }
04755         }
04756         if(node.getLPar() != null)
04757         {
04758             node.getLPar().apply(this);
04759         }
04760         if(node.getName() != null)
04761         {
04762             node.getName().apply(this);
04763         }
04764         if(node.getNew() != null)
04765         {
04766             node.getNew().apply(this);
04767         }
04768         outASimpleClassInstanceCreationExp(node);
04769     }
04770     public void caseASimpleName(ASimpleName node)
04771     {
04772         inASimpleName(node);
04773         if(node.getId() != null)
04774         {
04775             node.getId().apply(this);
04776         }
04777         outASimpleName(node);
04778     }
04779     public void caseASimpleNameName(ASimpleNameName node)
04780     {
04781         inASimpleNameName(node);
04782         if(node.getOneSimpleName() != null)
04783         {
04784             node.getOneSimpleName().apply(this);
04785         }
04786         outASimpleNameName(node);
04787     }
04788     public void caseASingleTypeImportDeclaration(ASingleTypeImportDeclaration node)
04789     {
04790         inASingleTypeImportDeclaration(node);
04791         if(node.getSemicolon() != null)
04792         {
04793             node.getSemicolon().apply(this);
04794         }
04795         if(node.getName() != null)
04796         {
04797             node.getName().apply(this);
04798         }
04799         if(node.getImport() != null)
04800         {
04801             node.getImport().apply(this);
04802         }
04803         outASingleTypeImportDeclaration(node);
04804     }
04805     public void caseASingleTypeImportDeclarationImportDeclaration(ASingleTypeImportDeclarationImportDeclaration node)
04806     {
04807         inASingleTypeImportDeclarationImportDeclaration(node);
04808         if(node.getOneSingleTypeImportDeclaration() != null)
04809         {
04810             node.getOneSingleTypeImportDeclaration().apply(this);
04811         }
04812         outASingleTypeImportDeclarationImportDeclaration(node);
04813     }
04814     public void caseAStarAssignAssignmentOperator(AStarAssignAssignmentOperator node)
04815     {
04816         inAStarAssignAssignmentOperator(node);
04817         if(node.getStarAssign() != null)
04818         {
04819             node.getStarAssign().apply(this);
04820         }
04821         outAStarAssignAssignmentOperator(node);
04822     }
04823     public void caseAStarBinaryOperator(AStarBinaryOperator node)
04824     {
04825         inAStarBinaryOperator(node);
04826         if(node.getStar() != null)
04827         {
04828             node.getStar().apply(this);
04829         }
04830         outAStarBinaryOperator(node);
04831     }
04832     public void caseAStarMultiplicativeExp(AStarMultiplicativeExp node)
04833     {
04834         inAStarMultiplicativeExp(node);
04835         if(node.getUnaryExp() != null)
04836         {
04837             node.getUnaryExp().apply(this);
04838         }
04839         if(node.getStar() != null)
04840         {
04841             node.getStar().apply(this);
04842         }
04843         if(node.getMultiplicativeExp() != null)
04844         {
04845             node.getMultiplicativeExp().apply(this);
04846         }
04847         outAStarMultiplicativeExp(node);
04848     }
04849     public void caseAStaticInitializer(AStaticInitializer node)
04850     {
04851         inAStaticInitializer(node);
04852         if(node.getBlock() != null)
04853         {
04854             node.getBlock().apply(this);
04855         }
04856         if(node.getStatic() != null)
04857         {
04858             node.getStatic().apply(this);
04859         }
04860         outAStaticInitializer(node);
04861     }
04862     public void caseAStaticInitializerClassBodyDeclaration(AStaticInitializerClassBodyDeclaration node)
04863     {
04864         inAStaticInitializerClassBodyDeclaration(node);
04865         if(node.getBlock() != null)
04866         {
04867             node.getBlock().apply(this);
04868         }
04869         if(node.getStatic() != null)
04870         {
04871             node.getStatic().apply(this);
04872         }
04873         outAStaticInitializerClassBodyDeclaration(node);
04874     }
04875     public void caseAStaticModifier(AStaticModifier node)
04876     {
04877         inAStaticModifier(node);
04878         if(node.getStatic() != null)
04879         {
04880             node.getStatic().apply(this);
04881         }
04882         outAStaticModifier(node);
04883     }
04884     public void caseAStmtBlockedStmt(AStmtBlockedStmt node)
04885     {
04886         inAStmtBlockedStmt(node);
04887         if(node.getStmt() != null)
04888         {
04889             node.getStmt().apply(this);
04890         }
04891         outAStmtBlockedStmt(node);
04892     }
04893     public void caseAStmtExpListForInit(AStmtExpListForInit node)
04894     {
04895         inAStmtExpListForInit(node);
04896         if(node.getStmtExpList() != null)
04897         {
04898             node.getStmtExpList().apply(this);
04899         }
04900         outAStmtExpListForInit(node);
04901     }
04902     public void caseAStmtExpListStmtExpList(AStmtExpListStmtExpList node)
04903     {
04904         inAStmtExpListStmtExpList(node);
04905         if(node.getStmtExp() != null)
04906         {
04907             node.getStmtExp().apply(this);
04908         }
04909         if(node.getComma() != null)
04910         {
04911             node.getComma().apply(this);
04912         }
04913         if(node.getStmtExpList() != null)
04914         {
04915             node.getStmtExpList().apply(this);
04916         }
04917         outAStmtExpListStmtExpList(node);
04918     }
04919     public void caseAStmtExpStmtExpList(AStmtExpStmtExpList node)
04920     {
04921         inAStmtExpStmtExpList(node);
04922         if(node.getStmtExp() != null)
04923         {
04924             node.getStmtExp().apply(this);
04925         }
04926         outAStmtExpStmtExpList(node);
04927     }
04928     public void caseAStmtWithoutTrailingSubstmtStmt(AStmtWithoutTrailingSubstmtStmt node)
04929     {
04930         inAStmtWithoutTrailingSubstmtStmt(node);
04931         if(node.getStmtWithoutTrailingSubstmt() != null)
04932         {
04933             node.getStmtWithoutTrailingSubstmt().apply(this);
04934         }
04935         outAStmtWithoutTrailingSubstmtStmt(node);
04936     }
04937     public void caseAStmtWithoutTrailingSubstmtStmtNoShortIf(AStmtWithoutTrailingSubstmtStmtNoShortIf node)
04938     {
04939         inAStmtWithoutTrailingSubstmtStmtNoShortIf(node);
04940         if(node.getStmtWithoutTrailingSubstmt() != null)
04941         {
04942             node.getStmtWithoutTrailingSubstmt().apply(this);
04943         }
04944         outAStmtWithoutTrailingSubstmtStmtNoShortIf(node);
04945     }
04946     public void caseAStringLiteralLiteral(AStringLiteralLiteral node)
04947     {
04948         inAStringLiteralLiteral(node);
04949         if(node.getStringLiteral() != null)
04950         {
04951             node.getStringLiteral().apply(this);
04952         }
04953         outAStringLiteralLiteral(node);
04954     }
04955     public void caseASuper(ASuper node)
04956     {
04957         inASuper(node);
04958         if(node.getClassType() != null)
04959         {
04960             node.getClassType().apply(this);
04961         }
04962         if(node.getExtends() != null)
04963         {
04964             node.getExtends().apply(this);
04965         }
04966         outASuper(node);
04967     }
04968     public void caseASuperConstructorInvocation(ASuperConstructorInvocation node)
04969     {
04970         inASuperConstructorInvocation(node);
04971         if(node.getSemicolon() != null)
04972         {
04973             node.getSemicolon().apply(this);
04974         }
04975         if(node.getRPar() != null)
04976         {
04977             node.getRPar().apply(this);
04978         }
04979         {
04980             Object temp[] = node.getArgumentList().toArray();
04981             for(int i = temp.length - 1; i >= 0; i--)
04982             {
04983                 ((PExp) temp[i]).apply(this);
04984             }
04985         }
04986         if(node.getLPar() != null)
04987         {
04988             node.getLPar().apply(this);
04989         }
04990         if(node.getSuper() != null)
04991         {
04992             node.getSuper().apply(this);
04993         }
04994         outASuperConstructorInvocation(node);
04995     }
04996     public void caseASuperFieldAccess(ASuperFieldAccess node)
04997     {
04998         inASuperFieldAccess(node);
04999         if(node.getId() != null)
05000         {
05001             node.getId().apply(this);
05002         }
05003         if(node.getDot() != null)
05004         {
05005             node.getDot().apply(this);
05006         }
05007         if(node.getSuper() != null)
05008         {
05009             node.getSuper().apply(this);
05010         }
05011         outASuperFieldAccess(node);
05012     }
05013     public void caseASuperMethodInvocation(ASuperMethodInvocation node)
05014     {
05015         inASuperMethodInvocation(node);
05016         if(node.getRPar() != null)
05017         {
05018             node.getRPar().apply(this);
05019         }
05020         if(node.getArgumentList() != null)
05021         {
05022             node.getArgumentList().apply(this);
05023         }
05024         if(node.getLPar() != null)
05025         {
05026             node.getLPar().apply(this);
05027         }
05028         if(node.getId() != null)
05029         {
05030             node.getId().apply(this);
05031         }
05032         if(node.getDot() != null)
05033         {
05034             node.getDot().apply(this);
05035         }
05036         if(node.getSuper() != null)
05037         {
05038             node.getSuper().apply(this);
05039         }
05040         outASuperMethodInvocation(node);
05041     }
05042     public void caseASuperMethodInvocationExp(ASuperMethodInvocationExp node)
05043     {
05044         inASuperMethodInvocationExp(node);
05045         if(node.getRPar() != null)
05046         {
05047             node.getRPar().apply(this);
05048         }
05049         {
05050             Object temp[] = node.getArgumentList().toArray();
05051             for(int i = temp.length - 1; i >= 0; i--)
05052             {
05053                 ((PExp) temp[i]).apply(this);
05054             }
05055         }
05056         if(node.getLPar() != null)
05057         {
05058             node.getLPar().apply(this);
05059         }
05060         if(node.getId() != null)
05061         {
05062             node.getId().apply(this);
05063         }
05064         if(node.getDot() != null)
05065         {
05066             node.getDot().apply(this);
05067         }
05068         if(node.getSuper() != null)
05069         {
05070             node.getSuper().apply(this);
05071         }
05072         outASuperMethodInvocationExp(node);
05073     }
05074     public void caseASwitchBlockStmtGroup(ASwitchBlockStmtGroup node)
05075     {
05076         inASwitchBlockStmtGroup(node);
05077         {
05078             Object temp[] = node.getBlockedStmt().toArray();
05079             for(int i = temp.length - 1; i >= 0; i--)
05080             {
05081                 ((PBlockedStmt) temp[i]).apply(this);
05082             }
05083         }
05084         {
05085             Object temp[] = node.getSwitchLabel().toArray();
05086             for(int i = temp.length - 1; i >= 0; i--)
05087             {
05088                 ((PSwitchLabel) temp[i]).apply(this);
05089             }
05090         }
05091         outASwitchBlockStmtGroup(node);
05092     }
05093     public void caseASwitchStmt(ASwitchStmt node)
05094     {
05095         inASwitchStmt(node);
05096         if(node.getRBrace() != null)
05097         {
05098             node.getRBrace().apply(this);
05099         }
05100         {
05101             Object temp[] = node.getSwitchLabel().toArray();
05102             for(int i = temp.length - 1; i >= 0; i--)
05103             {
05104                 ((PSwitchLabel) temp[i]).apply(this);
05105             }
05106         }
05107         {
05108             Object temp[] = node.getSwitchBlockStmtGroup().toArray();
05109             for(int i = temp.length - 1; i >= 0; i--)
05110             {
05111                 ((PSwitchBlockStmtGroup) temp[i]).apply(this);
05112             }
05113         }
05114         if(node.getLBrace() != null)
05115         {
05116             node.getLBrace().apply(this);
05117         }
05118         if(node.getRPar() != null)
05119         {
05120             node.getRPar().apply(this);
05121         }
05122         if(node.getExp() != null)
05123         {
05124             node.getExp().apply(this);
05125         }
05126         if(node.getLPar() != null)
05127         {
05128             node.getLPar().apply(this);
05129         }
05130         if(node.getSwitch() != null)
05131         {
05132             node.getSwitch().apply(this);
05133         }
05134         outASwitchStmt(node);
05135     }
05136     public void caseASwitchStmtStmtWithoutTrailingSubstmt(ASwitchStmtStmtWithoutTrailingSubstmt node)
05137     {
05138         inASwitchStmtStmtWithoutTrailingSubstmt(node);
05139         if(node.getOneSwitchStmt() != null)
05140         {
05141             node.getOneSwitchStmt().apply(this);
05142         }
05143         outASwitchStmtStmtWithoutTrailingSubstmt(node);
05144     }
05145     public void caseASynchronizedModifier(ASynchronizedModifier node)
05146     {
05147         inASynchronizedModifier(node);
05148         if(node.getSynchronized() != null)
05149         {
05150             node.getSynchronized().apply(this);
05151         }
05152         outASynchronizedModifier(node);
05153     }
05154     public void caseASynchronizedStmt(ASynchronizedStmt node)
05155     {
05156         inASynchronizedStmt(node);
05157         if(node.getBlock() != null)
05158         {
05159             node.getBlock().apply(this);
05160         }
05161         if(node.getRPar() != null)
05162         {
05163             node.getRPar().apply(this);
05164         }
05165         if(node.getExp() != null)
05166         {
05167             node.getExp().apply(this);
05168         }
05169         if(node.getLPar() != null)
05170         {
05171             node.getLPar().apply(this);
05172         }
05173         if(node.getSynchronized() != null)
05174         {
05175             node.getSynchronized().apply(this);
05176         }
05177         outASynchronizedStmt(node);
05178     }
05179     public void caseASynchronizedStmtStmtWithoutTrailingSubstmt(ASynchronizedStmtStmtWithoutTrailingSubstmt node)
05180     {
05181         inASynchronizedStmtStmtWithoutTrailingSubstmt(node);
05182         if(node.getOneSynchronizedStmt() != null)
05183         {
05184             node.getOneSynchronizedStmt().apply(this);
05185         }
05186         outASynchronizedStmtStmtWithoutTrailingSubstmt(node);
05187     }
05188     public void caseAThisConstructorInvocation(AThisConstructorInvocation node)
05189     {
05190         inAThisConstructorInvocation(node);
05191         if(node.getSemicolon() != null)
05192         {
05193             node.getSemicolon().apply(this);
05194         }
05195         if(node.getRPar() != null)
05196         {
05197             node.getRPar().apply(this);
05198         }
05199         {
05200             Object temp[] = node.getArgumentList().toArray();
05201             for(int i = temp.length - 1; i >= 0; i--)
05202             {
05203                 ((PExp) temp[i]).apply(this);
05204             }
05205         }
05206         if(node.getLPar() != null)
05207         {
05208             node.getLPar().apply(this);
05209         }
05210         if(node.getThis() != null)
05211         {
05212             node.getThis().apply(this);
05213         }
05214         outAThisConstructorInvocation(node);
05215     }
05216     public void caseAThisExp(AThisExp node)
05217     {
05218         inAThisExp(node);
05219         if(node.getThis() != null)
05220         {
05221             node.getThis().apply(this);
05222         }
05223         outAThisExp(node);
05224     }
05225     public void caseAThisPrimaryNoNewArray(AThisPrimaryNoNewArray node)
05226     {
05227         inAThisPrimaryNoNewArray(node);
05228         if(node.getThis() != null)
05229         {
05230             node.getThis().apply(this);
05231         }
05232         outAThisPrimaryNoNewArray(node);
05233     }
05234     public void caseAThrows(AThrows node)
05235     {
05236         inAThrows(node);
05237         {
05238             Object temp[] = node.getName().toArray();
05239             for(int i = temp.length - 1; i >= 0; i--)
05240             {
05241                 ((PName) temp[i]).apply(this);
05242             }
05243         }
05244         if(node.getThrows() != null)
05245         {
05246             node.getThrows().apply(this);
05247         }
05248         outAThrows(node);
05249     }
05250     public void caseAThrowStmt(AThrowStmt node)
05251     {
05252         inAThrowStmt(node);
05253         if(node.getSemicolon() != null)
05254         {
05255             node.getSemicolon().apply(this);
05256         }
05257         if(node.getExp() != null)
05258         {
05259             node.getExp().apply(this);
05260         }
05261         if(node.getThrow() != null)
05262         {
05263             node.getThrow().apply(this);
05264         }
05265         outAThrowStmt(node);
05266     }
05267     public void caseAThrowStmtStmtWithoutTrailingSubstmt(AThrowStmtStmtWithoutTrailingSubstmt node)
05268     {
05269         inAThrowStmtStmtWithoutTrailingSubstmt(node);
05270         if(node.getOneThrowStmt() != null)
05271         {
05272             node.getOneThrowStmt().apply(this);
05273         }
05274         outAThrowStmtStmtWithoutTrailingSubstmt(node);
05275     }
05276     public void caseATransientModifier(ATransientModifier node)
05277     {
05278         inATransientModifier(node);
05279         if(node.getTransient() != null)
05280         {
05281             node.getTransient().apply(this);
05282         }
05283         outATransientModifier(node);
05284     }
05285     public void caseATrueBooleanLiteral(ATrueBooleanLiteral node)
05286     {
05287         inATrueBooleanLiteral(node);
05288         if(node.getTrue() != null)
05289         {
05290             node.getTrue().apply(this);
05291         }
05292         outATrueBooleanLiteral(node);
05293     }
05294     public void caseATryFinallyStmt(ATryFinallyStmt node)
05295     {
05296         inATryFinallyStmt(node);
05297         if(node.getFinally() != null)
05298         {
05299             node.getFinally().apply(this);
05300         }
05301         {
05302             Object temp[] = node.getCatchClause().toArray();
05303             for(int i = temp.length - 1; i >= 0; i--)
05304             {
05305                 ((PCatchClause) temp[i]).apply(this);
05306             }
05307         }
05308         if(node.getBlock() != null)
05309         {
05310             node.getBlock().apply(this);
05311         }
05312         if(node.getTry() != null)
05313         {
05314             node.getTry().apply(this);
05315         }
05316         outATryFinallyStmt(node);
05317     }
05318     public void caseATryOneTryStmt(ATryOneTryStmt node)
05319     {
05320         inATryOneTryStmt(node);
05321         {
05322             Object temp[] = node.getCatchClause().toArray();
05323             for(int i = temp.length - 1; i >= 0; i--)
05324             {
05325                 ((PCatchClause) temp[i]).apply(this);
05326             }
05327         }
05328         if(node.getBlock() != null)
05329         {
05330             node.getBlock().apply(this);
05331         }
05332         if(node.getTry() != null)
05333         {
05334             node.getTry().apply(this);
05335         }
05336         outATryOneTryStmt(node);
05337     }
05338     public void caseATryStmt(ATryStmt node)
05339     {
05340         inATryStmt(node);
05341         {
05342             Object temp[] = node.getCatchClause().toArray();
05343             for(int i = temp.length - 1; i >= 0; i--)
05344             {
05345                 ((PCatchClause) temp[i]).apply(this);
05346             }
05347         }
05348         if(node.getBlock() != null)
05349         {
05350             node.getBlock().apply(this);
05351         }
05352         if(node.getTry() != null)
05353         {
05354             node.getTry().apply(this);
05355         }
05356         outATryStmt(node);
05357     }
05358     public void caseATryStmtStmtWithoutTrailingSubstmt(ATryStmtStmtWithoutTrailingSubstmt node)
05359     {
05360         inATryStmtStmtWithoutTrailingSubstmt(node);
05361         if(node.getOneTryStmt() != null)
05362         {
05363             node.getOneTryStmt().apply(this);
05364         }
05365         outATryStmtStmtWithoutTrailingSubstmt(node);
05366     }
05367     public void caseATypedMethodHeader(ATypedMethodHeader node)
05368     {
05369         inATypedMethodHeader(node);
05370         if(node.getThrows() != null)
05371         {
05372             node.getThrows().apply(this);
05373         }
05374         if(node.getMethodDeclarator() != null)
05375         {
05376             node.getMethodDeclarator().apply(this);
05377         }
05378         if(node.getType() != null)
05379         {
05380             node.getType().apply(this);
05381         }
05382         {
05383             Object temp[] = node.getModifier().toArray();
05384             for(int i = temp.length - 1; i >= 0; i--)
05385             {
05386                 ((PModifier) temp[i]).apply(this);
05387             }
05388         }
05389         outATypedMethodHeader(node);
05390     }
05391     public void caseATypeImportOnDemandDeclarationImportDeclaration(ATypeImportOnDemandDeclarationImportDeclaration node)
05392     {
05393         inATypeImportOnDemandDeclarationImportDeclaration(node);
05394         if(node.getOneTypeImportOnDemandDeclaration() != null)
05395         {
05396             node.getOneTypeImportOnDemandDeclaration().apply(this);
05397         }
05398         outATypeImportOnDemandDeclarationImportDeclaration(node);
05399     }
05400     public void caseATypeOnDemandImportDeclaration(ATypeOnDemandImportDeclaration node)
05401     {
05402         inATypeOnDemandImportDeclaration(node);
05403         if(node.getSemicolon() != null)
05404         {
05405             node.getSemicolon().apply(this);
05406         }
05407         if(node.getStar() != null)
05408         {
05409             node.getStar().apply(this);
05410         }
05411         if(node.getDot() != null)
05412         {
05413             node.getDot().apply(this);
05414         }
05415         if(node.getName() != null)
05416         {
05417             node.getName().apply(this);
05418         }
05419         if(node.getImport() != null)
05420         {
05421             node.getImport().apply(this);
05422         }
05423         outATypeOnDemandImportDeclaration(node);
05424     }
05425     public void caseAUnaryExp(AUnaryExp node)
05426     {
05427         inAUnaryExp(node);
05428         if(node.getExp() != null)
05429         {
05430             node.getExp().apply(this);
05431         }
05432         if(node.getUnaryOperator() != null)
05433         {
05434             node.getUnaryOperator().apply(this);
05435         }
05436         outAUnaryExp(node);
05437     }
05438     public void caseAUnaryExpMultiplicativeExp(AUnaryExpMultiplicativeExp node)
05439     {
05440         inAUnaryExpMultiplicativeExp(node);
05441         if(node.getUnaryExp() != null)
05442         {
05443             node.getUnaryExp().apply(this);
05444         }
05445         outAUnaryExpMultiplicativeExp(node);
05446     }
05447     public void caseAUnsignedShiftRightAssignAssignmentOperator(AUnsignedShiftRightAssignAssignmentOperator node)
05448     {
05449         inAUnsignedShiftRightAssignAssignmentOperator(node);
05450         if(node.getUnsignedShiftRightAssign() != null)
05451         {
05452             node.getUnsignedShiftRightAssign().apply(this);
05453         }
05454         outAUnsignedShiftRightAssignAssignmentOperator(node);
05455     }
05456     public void caseAUnsignedShiftRightBinaryOperator(AUnsignedShiftRightBinaryOperator node)
05457     {
05458         inAUnsignedShiftRightBinaryOperator(node);
05459         if(node.getUnsignedShiftRight() != null)
05460         {
05461             node.getUnsignedShiftRight().apply(this);
05462         }
05463         outAUnsignedShiftRightBinaryOperator(node);
05464     }
05465     public void caseAUnsignedShiftRightShiftExp(AUnsignedShiftRightShiftExp node)
05466     {
05467         inAUnsignedShiftRightShiftExp(node);
05468         if(node.getAdditiveExp() != null)
05469         {
05470             node.getAdditiveExp().apply(this);
05471         }
05472         if(node.getUnsignedShiftRight() != null)
05473         {
05474             node.getUnsignedShiftRight().apply(this);
05475         }
05476         if(node.getShiftExp() != null)
05477         {
05478             node.getShiftExp().apply(this);
05479         }
05480         outAUnsignedShiftRightShiftExp(node);
05481     }
05482     public void caseAVariableDeclaratorId(AVariableDeclaratorId node)
05483     {
05484         inAVariableDeclaratorId(node);
05485         {
05486             Object temp[] = node.getDim().toArray();
05487             for(int i = temp.length - 1; i >= 0; i--)
05488             {
05489                 ((PDim) temp[i]).apply(this);
05490             }
05491         }
05492         if(node.getId() != null)
05493         {
05494             node.getId().apply(this);
05495         }
05496         outAVariableDeclaratorId(node);
05497     }
05498     public void caseAVariableDeclaratorsVariableDeclarators(AVariableDeclaratorsVariableDeclarators node)
05499     {
05500         inAVariableDeclaratorsVariableDeclarators(node);
05501         if(node.getVariableDeclarator() != null)
05502         {
05503             node.getVariableDeclarator().apply(this);
05504         }
05505         if(node.getComma() != null)
05506         {
05507             node.getComma().apply(this);
05508         }
05509         if(node.getVariableDeclarators() != null)
05510         {
05511             node.getVariableDeclarators().apply(this);
05512         }
05513         outAVariableDeclaratorsVariableDeclarators(node);
05514     }
05515     public void caseAVariableDeclaratorVariableDeclarators(AVariableDeclaratorVariableDeclarators node)
05516     {
05517         inAVariableDeclaratorVariableDeclarators(node);
05518         if(node.getVariableDeclarator() != null)
05519         {
05520             node.getVariableDeclarator().apply(this);
05521         }
05522         outAVariableDeclaratorVariableDeclarators(node);
05523     }
05524     public void caseAVariableInitializersVariableInitializers(AVariableInitializersVariableInitializers node)
05525     {
05526         inAVariableInitializersVariableInitializers(node);
05527         if(node.getVariableInitializer() != null)
05528         {
05529             node.getVariableInitializer().apply(this);
05530         }
05531         if(node.getComma() != null)
05532         {
05533             node.getComma().apply(this);
05534         }
05535         if(node.getVariableInitializers() != null)
05536         {
05537             node.getVariableInitializers().apply(this);
05538         }
05539         outAVariableInitializersVariableInitializers(node);
05540     }
05541     public void caseAVariableInitializerVariableInitializers(AVariableInitializerVariableInitializers node)
05542     {
05543         inAVariableInitializerVariableInitializers(node);
05544         if(node.getVariableInitializer() != null)
05545         {
05546             node.getVariableInitializer().apply(this);
05547         }
05548         outAVariableInitializerVariableInitializers(node);
05549     }
05550     public void caseAVoidExp(AVoidExp node)
05551     {
05552         inAVoidExp(node);
05553         if(node.getTClass() != null)
05554         {
05555             node.getTClass().apply(this);
05556         }
05557         if(node.getDot() != null)
05558         {
05559             node.getDot().apply(this);
05560         }
05561         if(node.getVoid() != null)
05562         {
05563             node.getVoid().apply(this);
05564         }
05565         outAVoidExp(node);
05566     }
05567     public void caseAVoidMethodHeader(AVoidMethodHeader node)
05568     {
05569         inAVoidMethodHeader(node);
05570         if(node.getThrows() != null)
05571         {
05572             node.getThrows().apply(this);
05573         }
05574         if(node.getMethodDeclarator() != null)
05575         {
05576             node.getMethodDeclarator().apply(this);
05577         }
05578         if(node.getVoid() != null)
05579         {
05580             node.getVoid().apply(this);
05581         }
05582         {
05583             Object temp[] = node.getModifier().toArray();
05584             for(int i = temp.length - 1; i >= 0; i--)
05585             {
05586                 ((PModifier) temp[i]).apply(this);
05587             }
05588         }
05589         outAVoidMethodHeader(node);
05590     }
05591     public void caseAVoidPrimaryNoNewArray(AVoidPrimaryNoNewArray node)
05592     {
05593         inAVoidPrimaryNoNewArray(node);
05594         if(node.getTClass() != null)
05595         {
05596             node.getTClass().apply(this);
05597         }
05598         if(node.getDot() != null)
05599         {
05600             node.getDot().apply(this);
05601         }
05602         if(node.getVoid() != null)
05603         {
05604             node.getVoid().apply(this);
05605         }
05606         outAVoidPrimaryNoNewArray(node);
05607     }
05608     public void caseAVolatileModifier(AVolatileModifier node)
05609     {
05610         inAVolatileModifier(node);
05611         if(node.getVolatile() != null)
05612         {
05613             node.getVolatile().apply(this);
05614         }
05615         outAVolatileModifier(node);
05616     }
05617     public void caseAWhileStmt(AWhileStmt node)
05618     {
05619         inAWhileStmt(node);
05620         if(node.getBlock() != null)
05621         {
05622             node.getBlock().apply(this);
05623         }
05624         if(node.getRPar() != null)
05625         {
05626             node.getRPar().apply(this);
05627         }
05628         if(node.getExp() != null)
05629         {
05630             node.getExp().apply(this);
05631         }
05632         if(node.getLPar() != null)
05633         {
05634             node.getLPar().apply(this);
05635         }
05636         if(node.getWhile() != null)
05637         {
05638             node.getWhile().apply(this);
05639         }
05640         outAWhileStmt(node);
05641     }
05642     public void caseAWhileStmtNoShortIf(AWhileStmtNoShortIf node)
05643     {
05644         inAWhileStmtNoShortIf(node);
05645         if(node.getStmtNoShortIf() != null)
05646         {
05647             node.getStmtNoShortIf().apply(this);
05648         }
05649         if(node.getRPar() != null)
05650         {
05651             node.getRPar().apply(this);
05652         }
05653         if(node.getExp() != null)
05654         {
05655             node.getExp().apply(this);
05656         }
05657         if(node.getLPar() != null)
05658         {
05659             node.getLPar().apply(this);
05660         }
05661         if(node.getWhile() != null)
05662         {
05663             node.getWhile().apply(this);
05664         }
05665         outAWhileStmtNoShortIf(node);
05666     }
05667     public void caseAWhileStmtNoShortIfStmtNoShortIf(AWhileStmtNoShortIfStmtNoShortIf node)
05668     {
05669         inAWhileStmtNoShortIfStmtNoShortIf(node);
05670         if(node.getWhileStmtNoShortIf() != null)
05671         {
05672             node.getWhileStmtNoShortIf().apply(this);
05673         }
05674         outAWhileStmtNoShortIfStmtNoShortIf(node);
05675     }
05676     public void caseAWhileStmtStmt(AWhileStmtStmt node)
05677     {
05678         inAWhileStmtStmt(node);
05679         if(node.getOneWhileStmt() != null)
05680         {
05681             node.getOneWhileStmt().apply(this);
05682         }
05683         outAWhileStmtStmt(node);
05684     }
05685     public void caseStart(Start node)
05686     {
05687         inStart(node);
05688         node.getEOF().apply(this);
05689         node.getPCompilationUnit().apply(this);
05690         outStart(node);
05691     }
05692     public void defaultIn(Node node)
05693     {
05694     }
05695     public void defaultOut(Node node)
05696     {
05697     }
05698     public void inAAbstractMethodDeclaration(AAbstractMethodDeclaration node)
05699     {
05700         defaultIn(node);
05701     }
05702     public void inAAbstractMethodDeclarationInterfaceMemberDeclaration(AAbstractMethodDeclarationInterfaceMemberDeclaration node)
05703     {
05704         defaultIn(node);
05705     }
05706     public void inAAbstractModifier(AAbstractModifier node)
05707     {
05708         defaultIn(node);
05709     }
05710     public void inAAdditiveExpShiftExp(AAdditiveExpShiftExp node)
05711     {
05712         defaultIn(node);
05713     }
05714     public void inAAndBinaryOperator(AAndBinaryOperator node)
05715     {
05716         defaultIn(node);
05717     }
05718     public void inAAndExpAndExp(AAndExpAndExp node)
05719     {
05720         defaultIn(node);
05721     }
05722     public void inAAndExpExclusiveOrExp(AAndExpExclusiveOrExp node)
05723     {
05724         defaultIn(node);
05725     }
05726     public void inAArgumentListArgumentList(AArgumentListArgumentList node)
05727     {
05728         defaultIn(node);
05729     }
05730     public void inAArrayAccessExp(AArrayAccessExp node)
05731     {
05732         defaultIn(node);
05733     }
05734     public void inAArrayAccessLeftHandSide(AArrayAccessLeftHandSide node)
05735     {
05736         defaultIn(node);
05737     }
05738     public void inAArrayAccessPrimaryNoNewArray(AArrayAccessPrimaryNoNewArray node)
05739     {
05740         defaultIn(node);
05741     }
05742     public void inAArrayCreationExpPrimary(AArrayCreationExpPrimary node)
05743     {
05744         defaultIn(node);
05745     }
05746     public void inAArrayInitializer(AArrayInitializer node)
05747     {
05748         defaultIn(node);
05749     }
05750     public void inAArrayReferenceType(AArrayReferenceType node)
05751     {
05752         defaultIn(node);
05753     }
05754     public void inAArrayVariableInitializer(AArrayVariableInitializer node)
05755     {
05756         defaultIn(node);
05757     }
05758     public void inAAssertionCompilationUnit(AAssertionCompilationUnit node)
05759     {
05760         defaultIn(node);
05761     }
05762     public void inAAssignAssignmentOperator(AAssignAssignmentOperator node)
05763     {
05764         defaultIn(node);
05765     }
05766     public void inAAssignedVariableDeclarator(AAssignedVariableDeclarator node)
05767     {
05768         defaultIn(node);
05769     }
05770     public void inAAssignment(AAssignment node)
05771     {
05772         defaultIn(node);
05773     }
05774     public void inAAssignmentAssignmentExp(AAssignmentAssignmentExp node)
05775     {
05776         defaultIn(node);
05777     }
05778     public void inAAssignmentExp(AAssignmentExp node)
05779     {
05780         defaultIn(node);
05781     }
05782     public void inAAssignmentStmtExp(AAssignmentStmtExp node)
05783     {
05784         defaultIn(node);
05785     }
05786     public void inABinaryExp(ABinaryExp node)
05787     {
05788         defaultIn(node);
05789     }
05790     public void inABitAndAssignAssignmentOperator(ABitAndAssignAssignmentOperator node)
05791     {
05792         defaultIn(node);
05793     }
05794     public void inABitAndBinaryOperator(ABitAndBinaryOperator node)
05795     {
05796         defaultIn(node);
05797     }
05798     public void inABitComplementUnaryExpNotPlusMinus(ABitComplementUnaryExpNotPlusMinus node)
05799     {
05800         defaultIn(node);
05801     }
05802     public void inABitComplementUnaryOperator(ABitComplementUnaryOperator node)
05803     {
05804         defaultIn(node);
05805     }
05806     public void inABitOrAssignAssignmentOperator(ABitOrAssignAssignmentOperator node)
05807     {
05808         defaultIn(node);
05809     }
05810     public void inABitOrBinaryOperator(ABitOrBinaryOperator node)
05811     {
05812         defaultIn(node);
05813     }
05814     public void inABitXorAssignAssignmentOperator(ABitXorAssignAssignmentOperator node)
05815     {
05816         defaultIn(node);
05817     }
05818     public void inABitXorBinaryOperator(ABitXorBinaryOperator node)
05819     {
05820         defaultIn(node);
05821     }
05822     public void inABlock(ABlock node)
05823     {
05824         defaultIn(node);
05825     }
05826     public void inABlockClassBodyDeclaration(ABlockClassBodyDeclaration node)
05827     {
05828         defaultIn(node);
05829     }
05830     public void inABlockMethodBody(ABlockMethodBody node)
05831     {
05832         defaultIn(node);
05833     }
05834     public void inABlockStmt(ABlockStmt node)
05835     {
05836         defaultIn(node);
05837     }
05838     public void inABlockStmtWithoutTrailingSubstmt(ABlockStmtWithoutTrailingSubstmt node)
05839     {
05840         defaultIn(node);
05841     }
05842     public void inABooleanLiteralLiteral(ABooleanLiteralLiteral node)
05843     {
05844         defaultIn(node);
05845     }
05846     public void inABooleanPrimitiveType(ABooleanPrimitiveType node)
05847     {
05848         defaultIn(node);
05849     }
05850     public void inABreakStmt(ABreakStmt node)
05851     {
05852         defaultIn(node);
05853     }
05854     public void inABreakStmtStmtWithoutTrailingSubstmt(ABreakStmtStmtWithoutTrailingSubstmt node)
05855     {
05856         defaultIn(node);
05857     }
05858     public void inAByteIntegralType(AByteIntegralType node)
05859     {
05860         defaultIn(node);
05861     }
05862     public void inABytePrimitiveType(ABytePrimitiveType node)
05863     {
05864         defaultIn(node);
05865     }
05866     public void inACaseSwitchLabel(ACaseSwitchLabel node)
05867     {
05868         defaultIn(node);
05869     }
05870     public void inACastExpUnaryExpNotPlusMinus(ACastExpUnaryExpNotPlusMinus node)
05871     {
05872         defaultIn(node);
05873     }
05874     public void inACatchClause(ACatchClause node)
05875     {
05876         defaultIn(node);
05877     }
05878     public void inACharacterLiteralLiteral(ACharacterLiteralLiteral node)
05879     {
05880         defaultIn(node);
05881     }
05882     public void inACharIntegralType(ACharIntegralType node)
05883     {
05884         defaultIn(node);
05885     }
05886     public void inACharPrimitiveType(ACharPrimitiveType node)
05887     {
05888         defaultIn(node);
05889     }
05890     public void inAClassBody(AClassBody node)
05891     {
05892         defaultIn(node);
05893     }
05894     public void inAClassClassBodyDeclaration(AClassClassBodyDeclaration node)
05895     {
05896         defaultIn(node);
05897     }
05898     public void inAClassDeclaration(AClassDeclaration node)
05899     {
05900         defaultIn(node);
05901     }
05902     public void inAClassDeclarationBlockedStmt(AClassDeclarationBlockedStmt node)
05903     {
05904         defaultIn(node);
05905     }
05906     public void inAClassDeclarationClassMemberDeclaration(AClassDeclarationClassMemberDeclaration node)
05907     {
05908         defaultIn(node);
05909     }
05910     public void inAClassDeclarationInterfaceMemberDeclaration(AClassDeclarationInterfaceMemberDeclaration node)
05911     {
05912         defaultIn(node);
05913     }
05914     public void inAClassInstanceCreationExpPrimaryNoNewArray(AClassInstanceCreationExpPrimaryNoNewArray node)
05915     {
05916         defaultIn(node);
05917     }
05918     public void inAClassInstanceCreationExpStmtExp(AClassInstanceCreationExpStmtExp node)
05919     {
05920         defaultIn(node);
05921     }
05922     public void inAClassMemberDeclarationClassBodyDeclaration(AClassMemberDeclarationClassBodyDeclaration node)
05923     {
05924         defaultIn(node);
05925     }
05926     public void inAClassOrInterfaceType(AClassOrInterfaceType node)
05927     {
05928         defaultIn(node);
05929     }
05930     public void inAClassOrInterfaceTypeArrayCreationExp(AClassOrInterfaceTypeArrayCreationExp node)
05931     {
05932         defaultIn(node);
05933     }
05934     public void inAClassOrInterfaceTypeExp(AClassOrInterfaceTypeExp node)
05935     {
05936         defaultIn(node);
05937     }
05938     public void inAClassOrInterfaceTypeReferenceType(AClassOrInterfaceTypeReferenceType node)
05939     {
05940         defaultIn(node);
05941     }
05942     public void inAClassType(AClassType node)
05943     {
05944         defaultIn(node);
05945     }
05946     public void inAClassTypeClassTypeList(AClassTypeClassTypeList node)
05947     {
05948         defaultIn(node);
05949     }
05950     public void inAClassTypeDeclaration(AClassTypeDeclaration node)
05951     {
05952         defaultIn(node);
05953     }
05954     public void inAClassTypeListClassTypeList(AClassTypeListClassTypeList node)
05955     {
05956         defaultIn(node);
05957     }
05958     public void inACompilationUnit(ACompilationUnit node)
05959     {
05960         defaultIn(node);
05961     }
05962     public void inAComplementUnaryExpNotPlusMinus(AComplementUnaryExpNotPlusMinus node)
05963     {
05964         defaultIn(node);
05965     }
05966     public void inAComplementUnaryOperator(AComplementUnaryOperator node)
05967     {
05968         defaultIn(node);
05969     }
05970     public void inAConditionalAndExpConditionalAndExp(AConditionalAndExpConditionalAndExp node)
05971     {
05972         defaultIn(node);
05973     }
05974     public void inAConditionalAndExpConditionalOrExp(AConditionalAndExpConditionalOrExp node)
05975     {
05976         defaultIn(node);
05977     }
05978     public void inAConditionalExpAssignmentExp(AConditionalExpAssignmentExp node)
05979     {
05980         defaultIn(node);
05981     }
05982     public void inAConditionalOrExpConditionalExp(AConditionalOrExpConditionalExp node)
05983     {
05984         defaultIn(node);
05985     }
05986     public void inAConditionalOrExpConditionalOrExp(AConditionalOrExpConditionalOrExp node)
05987     {
05988         defaultIn(node);
05989     }
05990     public void inAConstantDeclaration(AConstantDeclaration node)
05991     {
05992         defaultIn(node);
05993     }
05994     public void inAConstantDeclarationInterfaceMemberDeclaration(AConstantDeclarationInterfaceMemberDeclaration node)
05995     {
05996         defaultIn(node);
05997     }
05998     public void inAConstantExp(AConstantExp node)
05999     {
06000         defaultIn(node);
06001     }
06002     public void inAConstructorBody(AConstructorBody node)
06003     {
06004         defaultIn(node);
06005     }
06006     public void inAConstructorClassBodyDeclaration(AConstructorClassBodyDeclaration node)
06007     {
06008         defaultIn(node);
06009     }
06010     public void inAConstructorDeclaration(AConstructorDeclaration node)
06011     {
06012         defaultIn(node);
06013     }
06014     public void inAConstructorDeclarator(AConstructorDeclarator node)
06015     {
06016         defaultIn(node);
06017     }
06018     public void inAContinueStmt(AContinueStmt node)
06019     {
06020         defaultIn(node);
06021     }
06022     public void inAContinueStmtStmtWithoutTrailingSubstmt(AContinueStmtStmtWithoutTrailingSubstmt node)
06023     {
06024         defaultIn(node);
06025     }
06026     public void inADecimalIntegerLiteral(ADecimalIntegerLiteral node)
06027     {
06028         defaultIn(node);
06029     }
06030     public void inADecrementUnaryOperator(ADecrementUnaryOperator node)
06031     {
06032         defaultIn(node);
06033     }
06034     public void inADefaultSwitchLabel(ADefaultSwitchLabel node)
06035     {
06036         defaultIn(node);
06037     }
06038     public void inADim(ADim node)
06039     {
06040         defaultIn(node);
06041     }
06042     public void inADimExp(ADimExp node)
06043     {
06044         defaultIn(node);
06045     }
06046     public void inADivAssignAssignmentOperator(ADivAssignAssignmentOperator node)
06047     {
06048         defaultIn(node);
06049     }
06050     public void inADivBinaryOperator(ADivBinaryOperator node)
06051     {
06052         defaultIn(node);
06053     }
06054     public void inADivMultiplicativeExp(ADivMultiplicativeExp node)
06055     {
06056         defaultIn(node);
06057     }
06058     public void inADoStmt(ADoStmt node)
06059     {
06060         defaultIn(node);
06061     }
06062     public void inADoStmtStmtWithoutTrailingSubstmt(ADoStmtStmtWithoutTrailingSubstmt node)
06063     {
06064         defaultIn(node);
06065     }
06066     public void inADoubleFloatingPointType(ADoubleFloatingPointType node)
06067     {
06068         defaultIn(node);
06069     }
06070     public void inADoublePrimitiveType(ADoublePrimitiveType node)
06071     {
06072         defaultIn(node);
06073     }
06074     public void inAEmptyMethodBody(AEmptyMethodBody node)
06075     {
06076         defaultIn(node);
06077     }
06078     public void inAEmptyStmt(AEmptyStmt node)
06079     {
06080         defaultIn(node);
06081     }
06082     public void inAEmptyStmtStmtWithoutTrailingSubstmt(AEmptyStmtStmtWithoutTrailingSubstmt node)
06083     {
06084         defaultIn(node);
06085     }
06086     public void inAEmptyTypeDeclaration(AEmptyTypeDeclaration node)
06087     {
06088         defaultIn(node);
06089     }
06090     public void inAEqBinaryOperator(AEqBinaryOperator node)
06091     {
06092         defaultIn(node);
06093     }
06094     public void inAEqEqualityExp(AEqEqualityExp node)
06095     {
06096         defaultIn(node);
06097     }
06098     public void inAEqualityExpAndExp(AEqualityExpAndExp node)
06099     {
06100         defaultIn(node);
06101     }
06102     public void inAExclusiveOrExpExclusiveOrExp(AExclusiveOrExpExclusiveOrExp node)
06103     {
06104         defaultIn(node);
06105     }
06106     public void inAExclusiveOrExpInclusiveOrExp(AExclusiveOrExpInclusiveOrExp node)
06107     {
06108         defaultIn(node);
06109     }
06110     public void inAExpArgumentList(AExpArgumentList node)
06111     {
06112         defaultIn(node);
06113     }
06114     public void inAExpCastExp(AExpCastExp node)
06115     {
06116         defaultIn(node);
06117     }
06118     public void inAExpListForInit(AExpListForInit node)
06119     {
06120         defaultIn(node);
06121     }
06122     public void inAExpStmt(AExpStmt node)
06123     {
06124         defaultIn(node);
06125     }
06126     public void inAExpStmtStmtWithoutTrailingSubstmt(AExpStmtStmtWithoutTrailingSubstmt node)
06127     {
06128         defaultIn(node);
06129     }
06130     public void inAExpVariableInitializer(AExpVariableInitializer node)
06131     {
06132         defaultIn(node);
06133     }
06134     public void inAExtendsExtendsInterfaces(AExtendsExtendsInterfaces node)
06135     {
06136         defaultIn(node);
06137     }
06138     public void inAExtendsInterfacesExtendsInterfaces(AExtendsInterfacesExtendsInterfaces node)
06139     {
06140         defaultIn(node);
06141     }
06142     public void inAFalseBooleanLiteral(AFalseBooleanLiteral node)
06143     {
06144         defaultIn(node);
06145     }
06146     public void inAFieldAccessExp(AFieldAccessExp node)
06147     {
06148         defaultIn(node);
06149     }
06150     public void inAFieldAccessLeftHandSide(AFieldAccessLeftHandSide node)
06151     {
06152         defaultIn(node);
06153     }
06154     public void inAFieldAccessPrimaryNoNewArray(AFieldAccessPrimaryNoNewArray node)
06155     {
06156         defaultIn(node);
06157     }
06158     public void inAFieldClassBodyDeclaration(AFieldClassBodyDeclaration node)
06159     {
06160         defaultIn(node);
06161     }
06162     public void inAFieldDeclaration(AFieldDeclaration node)
06163     {
06164         defaultIn(node);
06165     }
06166     public void inAFieldDeclarationClassMemberDeclaration(AFieldDeclarationClassMemberDeclaration node)
06167     {
06168         defaultIn(node);
06169     }
06170     public void inAFinally(AFinally node)
06171     {
06172         defaultIn(node);
06173     }
06174     public void inAFinallyOneTryStmt(AFinallyOneTryStmt node)
06175     {
06176         defaultIn(node);
06177     }
06178     public void inAFinalModifier(AFinalModifier node)
06179     {
06180         defaultIn(node);
06181     }
06182     public void inAFloatFloatingPointType(AFloatFloatingPointType node)
06183     {
06184         defaultIn(node);
06185     }
06186     public void inAFloatingPointLiteralLiteral(AFloatingPointLiteralLiteral node)
06187     {
06188         defaultIn(node);
06189     }
06190     public void inAFloatingPointTypeNumericType(AFloatingPointTypeNumericType node)
06191     {
06192         defaultIn(node);
06193     }
06194     public void inAFloatPrimitiveType(AFloatPrimitiveType node)
06195     {
06196         defaultIn(node);
06197     }
06198     public void inAFormalParameter(AFormalParameter node)
06199     {
06200         defaultIn(node);
06201     }
06202     public void inAFormalParameterFormalParameterList(AFormalParameterFormalParameterList node)
06203     {
06204         defaultIn(node);
06205     }
06206     public void inAFormalParameterListFormalParameterList(AFormalParameterListFormalParameterList node)
06207     {
06208         defaultIn(node);
06209     }
06210     public void inAForStmt(AForStmt node)
06211     {
06212         defaultIn(node);
06213     }
06214     public void inAForStmtNoShortIf(AForStmtNoShortIf node)
06215     {
06216         defaultIn(node);
06217     }
06218     public void inAForStmtNoShortIfStmtNoShortIf(AForStmtNoShortIfStmtNoShortIf node)
06219     {
06220         defaultIn(node);
06221     }
06222     public void inAForStmtStmt(AForStmtStmt node)
06223     {
06224         defaultIn(node);
06225     }
06226     public void inAForUpdate(AForUpdate node)
06227     {
06228         defaultIn(node);
06229     }
06230     public void inAGtBinaryOperator(AGtBinaryOperator node)
06231     {
06232         defaultIn(node);
06233     }
06234     public void inAGteqBinaryOperator(AGteqBinaryOperator node)
06235     {
06236         defaultIn(node);
06237     }
06238     public void inAGteqRelationalExp(AGteqRelationalExp node)
06239     {
06240         defaultIn(node);
06241     }
06242     public void inAGtRelationalExp(AGtRelationalExp node)
06243     {
06244         defaultIn(node);
06245     }
06246     public void inAHexIntegerLiteral(AHexIntegerLiteral node)
06247     {
06248         defaultIn(node);
06249     }
06250     public void inAIdVariableDeclarator(AIdVariableDeclarator node)
06251     {
06252         defaultIn(node);
06253     }
06254     public void inAIfStmt(AIfStmt node)
06255     {
06256         defaultIn(node);
06257     }
06258     public void inAIfThenElseStmt(AIfThenElseStmt node)
06259     {
06260         defaultIn(node);
06261     }
06262     public void inAIfThenElseStmtNoShortIf(AIfThenElseStmtNoShortIf node)
06263     {
06264         defaultIn(node);
06265     }
06266     public void inAIfThenElseStmtNoShortIfStmtNoShortIf(AIfThenElseStmtNoShortIfStmtNoShortIf node)
06267     {
06268         defaultIn(node);
06269     }
06270     public void inAIfThenElseStmtStmt(AIfThenElseStmtStmt node)
06271     {
06272         defaultIn(node);
06273     }
06274     public void inAIfThenStmt(AIfThenStmt node)
06275     {
06276         defaultIn(node);
06277     }
06278     public void inAIfThenStmtStmt(AIfThenStmtStmt node)
06279     {
06280         defaultIn(node);
06281     }
06282     public void inAInclusiveOrExpConditionalAndExp(AInclusiveOrExpConditionalAndExp node)
06283     {
06284         defaultIn(node);
06285     }
06286     public void inAInclusiveOrExpInclusiveOrExp(AInclusiveOrExpInclusiveOrExp node)
06287     {
06288         defaultIn(node);
06289     }
06290     public void inAIncrementUnaryOperator(AIncrementUnaryOperator node)
06291     {
06292         defaultIn(node);
06293     }
06294     public void inAInitClassInterfaceArrayCreationExp(AInitClassInterfaceArrayCreationExp node)
06295     {
06296         defaultIn(node);
06297     }
06298     public void inAInitClassInterfaceExp(AInitClassInterfaceExp node)
06299     {
06300         defaultIn(node);
06301     }
06302     public void inAInitPrimitiveArrayCreationExp(AInitPrimitiveArrayCreationExp node)
06303     {
06304         defaultIn(node);
06305     }
06306     public void inAInitPrimitiveExp(AInitPrimitiveExp node)
06307     {
06308         defaultIn(node);
06309     }
06310     public void inAInstanceofExp(AInstanceofExp node)
06311     {
06312         defaultIn(node);
06313     }
06314     public void inAInstanceofRelationalExp(AInstanceofRelationalExp node)
06315     {
06316         defaultIn(node);
06317     }
06318     public void inAIntegerLiteralLiteral(AIntegerLiteralLiteral node)
06319     {
06320         defaultIn(node);
06321     }
06322     public void inAIntegralTypeNumericType(AIntegralTypeNumericType node)
06323     {
06324         defaultIn(node);
06325     }
06326     public void inAInterfaceBody(AInterfaceBody node)
06327     {
06328         defaultIn(node);
06329     }
06330     public void inAInterfaceClassBodyDeclaration(AInterfaceClassBodyDeclaration node)
06331     {
06332         defaultIn(node);
06333     }
06334     public void inAInterfaceDeclaration(AInterfaceDeclaration node)
06335     {
06336         defaultIn(node);
06337     }
06338     public void inAInterfaceDeclarationClassMemberDeclaration(AInterfaceDeclarationClassMemberDeclaration node)
06339     {
06340         defaultIn(node);
06341     }
06342     public void inAInterfaceDeclarationInterfaceMemberDeclaration(AInterfaceDeclarationInterfaceMemberDeclaration node)
06343     {
06344         defaultIn(node);
06345     }
06346     public void inAInterfaces(AInterfaces node)
06347     {
06348         defaultIn(node);
06349     }
06350     public void inAInterfaceType(AInterfaceType node)
06351     {
06352         defaultIn(node);
06353     }
06354     public void inAInterfaceTypeDeclaration(AInterfaceTypeDeclaration node)
06355     {
06356         defaultIn(node);
06357     }
06358     public void inAInterfaceTypeInterfaceTypeList(AInterfaceTypeInterfaceTypeList node)
06359     {
06360         defaultIn(node);
06361     }
06362     public void inAInterfaceTypeListInterfaceTypeList(AInterfaceTypeListInterfaceTypeList node)
06363     {
06364         defaultIn(node);
06365     }
06366     public void inAIntIntegralType(AIntIntegralType node)
06367     {
06368         defaultIn(node);
06369     }
06370     public void inAIntPrimitiveType(AIntPrimitiveType node)
06371     {
06372         defaultIn(node);
06373     }
06374     public void inALabeledStmt(ALabeledStmt node)
06375     {
06376         defaultIn(node);
06377     }
06378     public void inALabeledStmtNoShortIf(ALabeledStmtNoShortIf node)
06379     {
06380         defaultIn(node);
06381     }
06382     public void inALabeledStmtNoShortIfStmtNoShortIf(ALabeledStmtNoShortIfStmtNoShortIf node)
06383     {
06384         defaultIn(node);
06385     }
06386     public void inALabeledStmtStmt(ALabeledStmtStmt node)
06387     {
06388         defaultIn(node);
06389     }
06390     public void inALabelStmt(ALabelStmt node)
06391     {
06392         defaultIn(node);
06393     }
06394     public void inALiteralExp(ALiteralExp node)
06395     {
06396         defaultIn(node);
06397     }
06398     public void inALiteralPrimaryNoNewArray(ALiteralPrimaryNoNewArray node)
06399     {
06400         defaultIn(node);
06401     }
06402     public void inALocalVariableDeclaration(ALocalVariableDeclaration node)
06403     {
06404         defaultIn(node);
06405     }
06406     public void inALocalVariableDeclarationForInit(ALocalVariableDeclarationForInit node)
06407     {
06408         defaultIn(node);
06409     }
06410     public void inALocalVariableDeclarationInBlockedStmt(ALocalVariableDeclarationInBlockedStmt node)
06411     {
06412         defaultIn(node);
06413     }
06414     public void inALocalVariableDeclarationStmt(ALocalVariableDeclarationStmt node)
06415     {
06416         defaultIn(node);
06417     }
06418     public void inALocalVariableDeclarationStmtBlockedStmt(ALocalVariableDeclarationStmtBlockedStmt node)
06419     {
06420         defaultIn(node);
06421     }
06422     public void inALongIntegralType(ALongIntegralType node)
06423     {
06424         defaultIn(node);
06425     }
06426     public void inALongPrimitiveType(ALongPrimitiveType node)
06427     {
06428         defaultIn(node);
06429     }
06430     public void inALParPrimaryNoNewArray(ALParPrimaryNoNewArray node)
06431     {
06432         defaultIn(node);
06433     }
06434     public void inALtBinaryOperator(ALtBinaryOperator node)
06435     {
06436         defaultIn(node);
06437     }
06438     public void inALteqBinaryOperator(ALteqBinaryOperator node)
06439     {
06440         defaultIn(node);
06441     }
06442     public void inALteqRelationalExp(ALteqRelationalExp node)
06443     {
06444         defaultIn(node);
06445     }
06446     public void inALtRelationalExp(ALtRelationalExp node)
06447     {
06448         defaultIn(node);
06449     }
06450     public void inAMethodClassBodyDeclaration(AMethodClassBodyDeclaration node)
06451     {
06452         defaultIn(node);
06453     }
06454     public void inAMethodDeclaration(AMethodDeclaration node)
06455     {
06456         defaultIn(node);
06457     }
06458     public void inAMethodDeclarationClassMemberDeclaration(AMethodDeclarationClassMemberDeclaration node)
06459     {
06460         defaultIn(node);
06461     }
06462     public void inAMethodDeclarator(AMethodDeclarator node)
06463     {
06464         defaultIn(node);
06465     }
06466     public void inAMethodInvocationPrimaryNoNewArray(AMethodInvocationPrimaryNoNewArray node)
06467     {
06468         defaultIn(node);
06469     }
06470     public void inAMethodInvocationStmtExp(AMethodInvocationStmtExp node)
06471     {
06472         defaultIn(node);
06473     }
06474     public void inAMinusAdditiveExp(AMinusAdditiveExp node)
06475     {
06476         defaultIn(node);
06477     }
06478     public void inAMinusAssignAssignmentOperator(AMinusAssignAssignmentOperator node)
06479     {
06480         defaultIn(node);
06481     }
06482     public void inAMinusBinaryOperator(AMinusBinaryOperator node)
06483     {
06484         defaultIn(node);
06485     }
06486     public void inAMinusUnaryExp(AMinusUnaryExp node)
06487     {
06488         defaultIn(node);
06489     }
06490     public void inAMinusUnaryOperator(AMinusUnaryOperator node)
06491     {
06492         defaultIn(node);
06493     }
06494     public void inAModAssignAssignmentOperator(AModAssignAssignmentOperator node)
06495     {
06496         defaultIn(node);
06497     }
06498     public void inAModBinaryOperator(AModBinaryOperator node)
06499     {
06500         defaultIn(node);
06501     }
06502     public void inAModMultiplicativeExp(AModMultiplicativeExp node)
06503     {
06504         defaultIn(node);
06505     }
06506     public void inAMultiplicativeExpAdditiveExp(AMultiplicativeExpAdditiveExp node)
06507     {
06508         defaultIn(node);
06509     }
06510     public void inANameArrayAccess(ANameArrayAccess node)
06511     {
06512         defaultIn(node);
06513     }
06514     public void inANameArrayType(ANameArrayType node)
06515     {
06516         defaultIn(node);
06517     }
06518     public void inANameCastExp(ANameCastExp node)
06519     {
06520         defaultIn(node);
06521     }
06522     public void inANamedTypeExp(ANamedTypeExp node)
06523     {
06524         defaultIn(node);
06525     }
06526     public void inANameExp(ANameExp node)
06527     {
06528         defaultIn(node);
06529     }
06530     public void inANameLeftHandSide(ANameLeftHandSide node)
06531     {
06532         defaultIn(node);
06533     }
06534     public void inANameMethodInvocation(ANameMethodInvocation node)
06535     {
06536         defaultIn(node);
06537     }
06538     public void inANameMethodInvocationExp(ANameMethodInvocationExp node)
06539     {
06540         defaultIn(node);
06541     }
06542     public void inANamePostfixExp(ANamePostfixExp node)
06543     {
06544         defaultIn(node);
06545     }
06546     public void inANameReferenceType(ANameReferenceType node)
06547     {
06548         defaultIn(node);
06549     }
06550     public void inANativeModifier(ANativeModifier node)
06551     {
06552         defaultIn(node);
06553     }
06554     public void inANeqBinaryOperator(ANeqBinaryOperator node)
06555     {
06556         defaultIn(node);
06557     }
06558     public void inANeqEqualityExp(ANeqEqualityExp node)
06559     {
06560         defaultIn(node);
06561     }
06562     public void inANotPlusMinusUnaryExp(ANotPlusMinusUnaryExp node)
06563     {
06564         defaultIn(node);
06565     }
06566     public void inANullLiteral(ANullLiteral node)
06567     {
06568         defaultIn(node);
06569     }
06570     public void inANullLiteralLiteral(ANullLiteralLiteral node)
06571     {
06572         defaultIn(node);
06573     }
06574     public void inANumericTypePrimitiveType(ANumericTypePrimitiveType node)
06575     {
06576         defaultIn(node);
06577     }
06578     public void inAOctalIntegerLiteral(AOctalIntegerLiteral node)
06579     {
06580         defaultIn(node);
06581     }
06582     public void inAOldAbstractMethodDeclarationInterfaceMemberDeclaration(AOldAbstractMethodDeclarationInterfaceMemberDeclaration node)
06583     {
06584         defaultIn(node);
06585     }
06586     public void inAOldArrayInitializer(AOldArrayInitializer node)
06587     {
06588         defaultIn(node);
06589     }
06590     public void inAOldCaseSwitchLabel(AOldCaseSwitchLabel node)
06591     {
06592         defaultIn(node);
06593     }
06594     public void inAOldCompilationUnit(AOldCompilationUnit node)
06595     {
06596         defaultIn(node);
06597     }
06598     public void inAOldConstantDeclarationInterfaceMemberDeclaration(AOldConstantDeclarationInterfaceMemberDeclaration node)
06599     {
06600         defaultIn(node);
06601     }
06602     public void inAOldConstructorDeclarator(AOldConstructorDeclarator node)
06603     {
06604         defaultIn(node);
06605     }
06606     public void inAOldExp(AOldExp node)
06607     {
06608         defaultIn(node);
06609     }
06610     public void inAOldExpCastExp(AOldExpCastExp node)
06611     {
06612         defaultIn(node);
06613     }
06614     public void inAOldFieldDeclaration(AOldFieldDeclaration node)
06615     {
06616         defaultIn(node);
06617     }
06618     public void inAOldInterfaceDeclaration(AOldInterfaceDeclaration node)
06619     {
06620         defaultIn(node);
06621     }
06622     public void inAOldInterfaces(AOldInterfaces node)
06623     {
06624         defaultIn(node);
06625     }
06626     public void inAOldLocalVariableDeclaration(AOldLocalVariableDeclaration node)
06627     {
06628         defaultIn(node);
06629     }
06630     public void inAOldMethodDeclarator(AOldMethodDeclarator node)
06631     {
06632         defaultIn(node);
06633     }
06634     public void inAOldNameCastExp(AOldNameCastExp node)
06635     {
06636         defaultIn(node);
06637     }
06638     public void inAOldNamedTypePrimaryNoNewArray(AOldNamedTypePrimaryNoNewArray node)
06639     {
06640         defaultIn(node);
06641     }
06642     public void inAOldPrimaryFieldAccess(AOldPrimaryFieldAccess node)
06643     {
06644         defaultIn(node);
06645     }
06646     public void inAOldPrimaryNoNewArrayArrayAccess(AOldPrimaryNoNewArrayArrayAccess node)
06647     {
06648         defaultIn(node);
06649     }
06650     public void inAOldPrimitiveTypeCastExp(AOldPrimitiveTypeCastExp node)
06651     {
06652         defaultIn(node);
06653     }
06654     public void inAOldPrimitiveTypePrimaryNoNewArray(AOldPrimitiveTypePrimaryNoNewArray node)
06655     {
06656         defaultIn(node);
06657     }
06658     public void inAOldQualifiedClassInstanceCreationExp(AOldQualifiedClassInstanceCreationExp node)
06659     {
06660         defaultIn(node);
06661     }
06662     public void inAOldQualifiedConstructorInvocation(AOldQualifiedConstructorInvocation node)
06663     {
06664         defaultIn(node);
06665     }
06666     public void inAOldSimpleClassInstanceCreationExp(AOldSimpleClassInstanceCreationExp node)
06667     {
06668         defaultIn(node);
06669     }
06670     public void inAOldStaticInitializerClassBodyDeclaration(AOldStaticInitializerClassBodyDeclaration node)
06671     {
06672         defaultIn(node);
06673     }
06674     public void inAOldSuper(AOldSuper node)
06675     {
06676         defaultIn(node);
06677     }
06678     public void inAOldSuperConstructorInvocation(AOldSuperConstructorInvocation node)
06679     {
06680         defaultIn(node);
06681     }
06682     public void inAOldThisConstructorInvocation(AOldThisConstructorInvocation node)
06683     {
06684         defaultIn(node);
06685     }
06686     public void inAOldThrows(AOldThrows node)
06687     {
06688         defaultIn(node);
06689     }
06690     public void inAOneBreakStmt(AOneBreakStmt node)
06691     {
06692         defaultIn(node);
06693     }
06694     public void inAOneContinueStmt(AOneContinueStmt node)
06695     {
06696         defaultIn(node);
06697     }
06698     public void inAOneDoStmt(AOneDoStmt node)
06699     {
06700         defaultIn(node);
06701     }
06702     public void inAOneForStmt(AOneForStmt node)
06703     {
06704         defaultIn(node);
06705     }
06706     public void inAOneQualifiedName(AOneQualifiedName node)
06707     {
06708         defaultIn(node);
06709     }
06710     public void inAOneReturnStmt(AOneReturnStmt node)
06711     {
06712         defaultIn(node);
06713     }
06714     public void inAOneSimpleName(AOneSimpleName node)
06715     {
06716         defaultIn(node);
06717     }
06718     public void inAOneSingleTypeImportDeclaration(AOneSingleTypeImportDeclaration node)
06719     {
06720         defaultIn(node);
06721     }
06722     public void inAOneSwitchStmt(AOneSwitchStmt node)
06723     {
06724         defaultIn(node);
06725     }
06726     public void inAOneSynchronizedStmt(AOneSynchronizedStmt node)
06727     {
06728         defaultIn(node);
06729     }
06730     public void inAOneThrowStmt(AOneThrowStmt node)
06731     {
06732         defaultIn(node);
06733     }
06734     public void inAOneTypeImportOnDemandDeclaration(AOneTypeImportOnDemandDeclaration node)
06735     {
06736         defaultIn(node);
06737     }
06738     public void inAOneWhileStmt(AOneWhileStmt node)
06739     {
06740         defaultIn(node);
06741     }
06742     public void inAOrBinaryOperator(AOrBinaryOperator node)
06743     {
06744         defaultIn(node);
06745     }
06746     public void inAOriginalExpStmt(AOriginalExpStmt node)
06747     {
06748         defaultIn(node);
06749     }
06750     public void inAPackageDeclaration(APackageDeclaration node)
06751     {
06752         defaultIn(node);
06753     }
06754     public void inAParExp(AParExp node)
06755     {
06756         defaultIn(node);
06757     }
06758     public void inAPlusAdditiveExp(APlusAdditiveExp node)
06759     {
06760         defaultIn(node);
06761     }
06762     public void inAPlusAssignAssignmentOperator(APlusAssignAssignmentOperator node)
06763     {
06764         defaultIn(node);
06765     }
06766     public void inAPlusBinaryOperator(APlusBinaryOperator node)
06767     {
06768         defaultIn(node);
06769     }
06770     public void inAPlusUnaryExp(APlusUnaryExp node)
06771     {
06772         defaultIn(node);
06773     }
06774     public void inAPlusUnaryOperator(APlusUnaryOperator node)
06775     {
06776         defaultIn(node);
06777     }
06778     public void inAPostDecrementExp(APostDecrementExp node)
06779     {
06780         defaultIn(node);
06781     }
06782     public void inAPostDecrementExpPostfixExp(APostDecrementExpPostfixExp node)
06783     {
06784         defaultIn(node);
06785     }
06786     public void inAPostDecrementExpr(APostDecrementExpr node)
06787     {
06788         defaultIn(node);
06789     }
06790     public void inAPostDecrementExpStmtExp(APostDecrementExpStmtExp node)
06791     {
06792         defaultIn(node);
06793     }
06794     public void inAPostfixExpUnaryExpNotPlusMinus(APostfixExpUnaryExpNotPlusMinus node)
06795     {
06796         defaultIn(node);
06797     }
06798     public void inAPostIncrementExp(APostIncrementExp node)
06799     {
06800         defaultIn(node);
06801     }
06802     public void inAPostIncrementExpPostfixExp(APostIncrementExpPostfixExp node)
06803     {
06804         defaultIn(node);
06805     }
06806     public void inAPostIncrementExpr(APostIncrementExpr node)
06807     {
06808         defaultIn(node);
06809     }
06810     public void inAPostIncrementExpStmtExp(APostIncrementExpStmtExp node)
06811     {
06812         defaultIn(node);
06813     }
06814     public void inAPreDecrementExp(APreDecrementExp node)
06815     {
06816         defaultIn(node);
06817     }
06818     public void inAPreDecrementExpStmtExp(APreDecrementExpStmtExp node)
06819     {
06820         defaultIn(node);
06821     }
06822     public void inAPreDecrementExpUnaryExp(APreDecrementExpUnaryExp node)
06823     {
06824         defaultIn(node);
06825     }
06826     public void inAPreIncrementExp(APreIncrementExp node)
06827     {
06828         defaultIn(node);
06829     }
06830     public void inAPreIncrementExpStmtExp(APreIncrementExpStmtExp node)
06831     {
06832         defaultIn(node);
06833     }
06834     public void inAPreIncrementExpUnaryExp(APreIncrementExpUnaryExp node)
06835     {
06836         defaultIn(node);
06837     }
06838     public void inAPrimaryFieldAccess(APrimaryFieldAccess node)
06839     {
06840         defaultIn(node);
06841     }
06842     public void inAPrimaryMethodInvocation(APrimaryMethodInvocation node)
06843     {
06844         defaultIn(node);
06845     }
06846     public void inAPrimaryMethodInvocationExp(APrimaryMethodInvocationExp node)
06847     {
06848         defaultIn(node);
06849     }
06850     public void inAPrimaryNoNewArrayArrayAccess(APrimaryNoNewArrayArrayAccess node)
06851     {
06852         defaultIn(node);
06853     }
06854     public void inAPrimaryNoNewArrayPrimary(APrimaryNoNewArrayPrimary node)
06855     {
06856         defaultIn(node);
06857     }
06858     public void inAPrimaryPostfixExp(APrimaryPostfixExp node)
06859     {
06860         defaultIn(node);
06861     }
06862     public void inAPrimitiveArrayType(APrimitiveArrayType node)
06863     {
06864         defaultIn(node);
06865     }
06866     public void inAPrimitiveType(APrimitiveType node)
06867     {
06868         defaultIn(node);
06869     }
06870     public void inAPrimitiveTypeArrayCreationExp(APrimitiveTypeArrayCreationExp node)
06871     {
06872         defaultIn(node);
06873     }
06874     public void inAPrimitiveTypeArrayExp(APrimitiveTypeArrayExp node)
06875     {
06876         defaultIn(node);
06877     }
06878     public void inAPrimitiveTypeCastExp(APrimitiveTypeCastExp node)
06879     {
06880         defaultIn(node);
06881     }
06882     public void inAPrimitiveTypePrimaryExp(APrimitiveTypePrimaryExp node)
06883     {
06884         defaultIn(node);
06885     }
06886     public void inAPrivateModifier(APrivateModifier node)
06887     {
06888         defaultIn(node);
06889     }
06890     public void inAProtectedModifier(AProtectedModifier node)
06891     {
06892         defaultIn(node);
06893     }
06894     public void inAPublicModifier(APublicModifier node)
06895     {
06896         defaultIn(node);
06897     }
06898     public void inAQualifiedClassInstanceCreationExp(AQualifiedClassInstanceCreationExp node)
06899     {
06900         defaultIn(node);
06901     }
06902     public void inAQualifiedConstructorInvocation(AQualifiedConstructorInvocation node)
06903     {
06904         defaultIn(node);
06905     }
06906     public void inAQualifiedName(AQualifiedName node)
06907     {
06908         defaultIn(node);
06909     }
06910     public void inAQualifiedNameName(AQualifiedNameName node)
06911     {
06912         defaultIn(node);
06913     }
06914     public void inAQualifiedThisExp(AQualifiedThisExp node)
06915     {
06916         defaultIn(node);
06917     }
06918     public void inAQualifiedThisPrimaryNoNewArray(AQualifiedThisPrimaryNoNewArray node)
06919     {
06920         defaultIn(node);
06921     }
06922     public void inAQuestionConditionalExp(AQuestionConditionalExp node)
06923     {
06924         defaultIn(node);
06925     }
06926     public void inAQuestionExp(AQuestionExp node)
06927     {
06928         defaultIn(node);
06929     }
06930     public void inAReferenceType(AReferenceType node)
06931     {
06932         defaultIn(node);
06933     }
06934     public void inARelationalExpEqualityExp(ARelationalExpEqualityExp node)
06935     {
06936         defaultIn(node);
06937     }
06938     public void inAReturnStmt(AReturnStmt node)
06939     {
06940         defaultIn(node);
06941     }
06942     public void inAReturnStmtStmtWithoutTrailingSubstmt(AReturnStmtStmtWithoutTrailingSubstmt node)
06943     {
06944         defaultIn(node);
06945     }
06946     public void inASemicolonStmt(ASemicolonStmt node)
06947     {
06948         defaultIn(node);
06949     }
06950     public void inAShiftExpRelationalExp(AShiftExpRelationalExp node)
06951     {
06952         defaultIn(node);
06953     }
06954     public void inAShiftLeftAssignAssignmentOperator(AShiftLeftAssignAssignmentOperator node)
06955     {
06956         defaultIn(node);
06957     }
06958     public void inAShiftLeftBinaryOperator(AShiftLeftBinaryOperator node)
06959     {
06960         defaultIn(node);
06961     }
06962     public void inAShiftLeftShiftExp(AShiftLeftShiftExp node)
06963     {
06964         defaultIn(node);
06965     }
06966     public void inAShortIntegralType(AShortIntegralType node)
06967     {
06968         defaultIn(node);
06969     }
06970     public void inAShortPrimitiveType(AShortPrimitiveType node)
06971     {
06972         defaultIn(node);
06973     }
06974     public void inASignedShiftRightAssignAssignmentOperator(ASignedShiftRightAssignAssignmentOperator node)
06975     {
06976         defaultIn(node);
06977     }
06978     public void inASignedShiftRightBinaryOperator(ASignedShiftRightBinaryOperator node)
06979     {
06980         defaultIn(node);
06981     }
06982     public void inASignedShiftRightShiftExp(ASignedShiftRightShiftExp node)
06983     {
06984         defaultIn(node);
06985     }
06986     public void inASimpleClassInstanceCreationExp(ASimpleClassInstanceCreationExp node)
06987     {
06988         defaultIn(node);
06989     }
06990     public void inASimpleName(ASimpleName node)
06991     {
06992         defaultIn(node);
06993     }
06994     public void inASimpleNameName(ASimpleNameName node)
06995     {
06996         defaultIn(node);
06997     }
06998     public void inASingleTypeImportDeclaration(ASingleTypeImportDeclaration node)
06999     {
07000         defaultIn(node);
07001     }
07002     public void inASingleTypeImportDeclarationImportDeclaration(ASingleTypeImportDeclarationImportDeclaration node)
07003     {
07004         defaultIn(node);
07005     }
07006     public void inAStarAssignAssignmentOperator(AStarAssignAssignmentOperator node)
07007     {
07008         defaultIn(node);
07009     }
07010     public void inAStarBinaryOperator(AStarBinaryOperator node)
07011     {
07012         defaultIn(node);
07013     }
07014     public void inAStarMultiplicativeExp(AStarMultiplicativeExp node)
07015     {
07016         defaultIn(node);
07017     }
07018     public void inAStaticInitializer(AStaticInitializer node)
07019     {
07020         defaultIn(node);
07021     }
07022     public void inAStaticInitializerClassBodyDeclaration(AStaticInitializerClassBodyDeclaration node)
07023     {
07024         defaultIn(node);
07025     }
07026     public void inAStaticModifier(AStaticModifier node)
07027     {
07028         defaultIn(node);
07029     }
07030     public void inAStmtBlockedStmt(AStmtBlockedStmt node)
07031     {
07032         defaultIn(node);
07033     }
07034     public void inAStmtExpListForInit(AStmtExpListForInit node)
07035     {
07036         defaultIn(node);
07037     }
07038     public void inAStmtExpListStmtExpList(AStmtExpListStmtExpList node)
07039     {
07040         defaultIn(node);
07041     }
07042     public void inAStmtExpStmtExpList(AStmtExpStmtExpList node)
07043     {
07044         defaultIn(node);
07045     }
07046     public void inAStmtWithoutTrailingSubstmtStmt(AStmtWithoutTrailingSubstmtStmt node)
07047     {
07048         defaultIn(node);
07049     }
07050     public void inAStmtWithoutTrailingSubstmtStmtNoShortIf(AStmtWithoutTrailingSubstmtStmtNoShortIf node)
07051     {
07052         defaultIn(node);
07053     }
07054     public void inAStringLiteralLiteral(AStringLiteralLiteral node)
07055     {
07056         defaultIn(node);
07057     }
07058     public void inASuper(ASuper node)
07059     {
07060         defaultIn(node);
07061     }
07062     public void inASuperConstructorInvocation(ASuperConstructorInvocation node)
07063     {
07064         defaultIn(node);
07065     }
07066     public void inASuperFieldAccess(ASuperFieldAccess node)
07067     {
07068         defaultIn(node);
07069     }
07070     public void inASuperMethodInvocation(ASuperMethodInvocation node)
07071     {
07072         defaultIn(node);
07073     }
07074     public void inASuperMethodInvocationExp(ASuperMethodInvocationExp node)
07075     {
07076         defaultIn(node);
07077     }
07078     public void inASwitchBlockStmtGroup(ASwitchBlockStmtGroup node)
07079     {
07080         defaultIn(node);
07081     }
07082     public void inASwitchStmt(ASwitchStmt node)
07083     {
07084         defaultIn(node);
07085     }
07086     public void inASwitchStmtStmtWithoutTrailingSubstmt(ASwitchStmtStmtWithoutTrailingSubstmt node)
07087     {
07088         defaultIn(node);
07089     }
07090     public void inASynchronizedModifier(ASynchronizedModifier node)
07091     {
07092         defaultIn(node);
07093     }
07094     public void inASynchronizedStmt(ASynchronizedStmt node)
07095     {
07096         defaultIn(node);
07097     }
07098     public void inASynchronizedStmtStmtWithoutTrailingSubstmt(ASynchronizedStmtStmtWithoutTrailingSubstmt node)
07099     {
07100         defaultIn(node);
07101     }
07102     public void inAThisConstructorInvocation(AThisConstructorInvocation node)
07103     {
07104         defaultIn(node);
07105     }
07106     public void inAThisExp(AThisExp node)
07107     {
07108         defaultIn(node);
07109     }
07110     public void inAThisPrimaryNoNewArray(AThisPrimaryNoNewArray node)
07111     {
07112         defaultIn(node);
07113     }
07114     public void inAThrows(AThrows node)
07115     {
07116         defaultIn(node);
07117     }
07118     public void inAThrowStmt(AThrowStmt node)
07119     {
07120         defaultIn(node);
07121     }
07122     public void inAThrowStmtStmtWithoutTrailingSubstmt(AThrowStmtStmtWithoutTrailingSubstmt node)
07123     {
07124         defaultIn(node);
07125     }
07126     public void inATransientModifier(ATransientModifier node)
07127     {
07128         defaultIn(node);
07129     }
07130     public void inATrueBooleanLiteral(ATrueBooleanLiteral node)
07131     {
07132         defaultIn(node);
07133     }
07134     public void inATryFinallyStmt(ATryFinallyStmt node)
07135     {
07136         defaultIn(node);
07137     }
07138     public void inATryOneTryStmt(ATryOneTryStmt node)
07139     {
07140         defaultIn(node);
07141     }
07142     public void inATryStmt(ATryStmt node)
07143     {
07144         defaultIn(node);
07145     }
07146     public void inATryStmtStmtWithoutTrailingSubstmt(ATryStmtStmtWithoutTrailingSubstmt node)
07147     {
07148         defaultIn(node);
07149     }
07150     public void inATypedMethodHeader(ATypedMethodHeader node)
07151     {
07152         defaultIn(node);
07153     }
07154     public void inATypeImportOnDemandDeclarationImportDeclaration(ATypeImportOnDemandDeclarationImportDeclaration node)
07155     {
07156         defaultIn(node);
07157     }
07158     public void inATypeOnDemandImportDeclaration(ATypeOnDemandImportDeclaration node)
07159     {
07160         defaultIn(node);
07161     }
07162     public void inAUnaryExp(AUnaryExp node)
07163     {
07164         defaultIn(node);
07165     }
07166     public void inAUnaryExpMultiplicativeExp(AUnaryExpMultiplicativeExp node)
07167     {
07168         defaultIn(node);
07169     }
07170     public void inAUnsignedShiftRightAssignAssignmentOperator(AUnsignedShiftRightAssignAssignmentOperator node)
07171     {
07172         defaultIn(node);
07173     }
07174     public void inAUnsignedShiftRightBinaryOperator(AUnsignedShiftRightBinaryOperator node)
07175     {
07176         defaultIn(node);
07177     }
07178     public void inAUnsignedShiftRightShiftExp(AUnsignedShiftRightShiftExp node)
07179     {
07180         defaultIn(node);
07181     }
07182     public void inAVariableDeclaratorId(AVariableDeclaratorId node)
07183     {
07184         defaultIn(node);
07185     }
07186     public void inAVariableDeclaratorsVariableDeclarators(AVariableDeclaratorsVariableDeclarators node)
07187     {
07188         defaultIn(node);
07189     }
07190     public void inAVariableDeclaratorVariableDeclarators(AVariableDeclaratorVariableDeclarators node)
07191     {
07192         defaultIn(node);
07193     }
07194     public void inAVariableInitializersVariableInitializers(AVariableInitializersVariableInitializers node)
07195     {
07196         defaultIn(node);
07197     }
07198     public void inAVariableInitializerVariableInitializers(AVariableInitializerVariableInitializers node)
07199     {
07200         defaultIn(node);
07201     }
07202     public void inAVoidExp(AVoidExp node)
07203     {
07204         defaultIn(node);
07205     }
07206     public void inAVoidMethodHeader(AVoidMethodHeader node)
07207     {
07208         defaultIn(node);
07209     }
07210     public void inAVoidPrimaryNoNewArray(AVoidPrimaryNoNewArray node)
07211     {
07212         defaultIn(node);
07213     }
07214     public void inAVolatileModifier(AVolatileModifier node)
07215     {
07216         defaultIn(node);
07217     }
07218     public void inAWhileStmt(AWhileStmt node)
07219     {
07220         defaultIn(node);
07221     }
07222     public void inAWhileStmtNoShortIf(AWhileStmtNoShortIf node)
07223     {
07224         defaultIn(node);
07225     }
07226     public void inAWhileStmtNoShortIfStmtNoShortIf(AWhileStmtNoShortIfStmtNoShortIf node)
07227     {
07228         defaultIn(node);
07229     }
07230     public void inAWhileStmtStmt(AWhileStmtStmt node)
07231     {
07232         defaultIn(node);
07233     }
07234     public void inStart(Start node)
07235     {
07236         defaultIn(node);
07237     }
07238     public void outAAbstractMethodDeclaration(AAbstractMethodDeclaration node)
07239     {
07240         defaultOut(node);
07241     }
07242     public void outAAbstractMethodDeclarationInterfaceMemberDeclaration(AAbstractMethodDeclarationInterfaceMemberDeclaration node)
07243     {
07244         defaultOut(node);
07245     }
07246     public void outAAbstractModifier(AAbstractModifier node)
07247     {
07248         defaultOut(node);
07249     }
07250     public void outAAdditiveExpShiftExp(AAdditiveExpShiftExp node)
07251     {
07252         defaultOut(node);
07253     }
07254     public void outAAndBinaryOperator(AAndBinaryOperator node)
07255     {
07256         defaultOut(node);
07257     }
07258     public void outAAndExpAndExp(AAndExpAndExp node)
07259     {
07260         defaultOut(node);
07261     }
07262     public void outAAndExpExclusiveOrExp(AAndExpExclusiveOrExp node)
07263     {
07264         defaultOut(node);
07265     }
07266     public void outAArgumentListArgumentList(AArgumentListArgumentList node)
07267     {
07268         defaultOut(node);
07269     }
07270     public void outAArrayAccessExp(AArrayAccessExp node)
07271     {
07272         defaultOut(node);
07273     }
07274     public void outAArrayAccessLeftHandSide(AArrayAccessLeftHandSide node)
07275     {
07276         defaultOut(node);
07277     }
07278     public void outAArrayAccessPrimaryNoNewArray(AArrayAccessPrimaryNoNewArray node)
07279     {
07280         defaultOut(node);
07281     }
07282     public void outAArrayCreationExpPrimary(AArrayCreationExpPrimary node)
07283     {
07284         defaultOut(node);
07285     }
07286     public void outAArrayInitializer(AArrayInitializer node)
07287     {
07288         defaultOut(node);
07289     }
07290     public void outAArrayReferenceType(AArrayReferenceType node)
07291     {
07292         defaultOut(node);
07293     }
07294     public void outAArrayVariableInitializer(AArrayVariableInitializer node)
07295     {
07296         defaultOut(node);
07297     }
07298     public void outAAssertionCompilationUnit(AAssertionCompilationUnit node)
07299     {
07300         defaultOut(node);
07301     }
07302     public void outAAssignAssignmentOperator(AAssignAssignmentOperator node)
07303     {
07304         defaultOut(node);
07305     }
07306     public void outAAssignedVariableDeclarator(AAssignedVariableDeclarator node)
07307     {
07308         defaultOut(node);
07309     }
07310     public void outAAssignment(AAssignment node)
07311     {
07312         defaultOut(node);
07313     }
07314     public void outAAssignmentAssignmentExp(AAssignmentAssignmentExp node)
07315     {
07316         defaultOut(node);
07317     }
07318     public void outAAssignmentExp(AAssignmentExp node)
07319     {
07320         defaultOut(node);
07321     }
07322     public void outAAssignmentStmtExp(AAssignmentStmtExp node)
07323     {
07324         defaultOut(node);
07325     }
07326     public void outABinaryExp(ABinaryExp node)
07327     {
07328         defaultOut(node);
07329     }
07330     public void outABitAndAssignAssignmentOperator(ABitAndAssignAssignmentOperator node)
07331     {
07332         defaultOut(node);
07333     }
07334     public void outABitAndBinaryOperator(ABitAndBinaryOperator node)
07335     {
07336         defaultOut(node);
07337     }
07338     public void outABitComplementUnaryExpNotPlusMinus(ABitComplementUnaryExpNotPlusMinus node)
07339     {
07340         defaultOut(node);
07341     }
07342     public void outABitComplementUnaryOperator(ABitComplementUnaryOperator node)
07343     {
07344         defaultOut(node);
07345     }
07346     public void outABitOrAssignAssignmentOperator(ABitOrAssignAssignmentOperator node)
07347     {
07348         defaultOut(node);
07349     }
07350     public void outABitOrBinaryOperator(ABitOrBinaryOperator node)
07351     {
07352         defaultOut(node);
07353     }
07354     public void outABitXorAssignAssignmentOperator(ABitXorAssignAssignmentOperator node)
07355     {
07356         defaultOut(node);
07357     }
07358     public void outABitXorBinaryOperator(ABitXorBinaryOperator node)
07359     {
07360         defaultOut(node);
07361     }
07362     public void outABlock(ABlock node)
07363     {
07364         defaultOut(node);
07365     }
07366     public void outABlockClassBodyDeclaration(ABlockClassBodyDeclaration node)
07367     {
07368         defaultOut(node);
07369     }
07370     public void outABlockMethodBody(ABlockMethodBody node)
07371     {
07372         defaultOut(node);
07373     }
07374     public void outABlockStmt(ABlockStmt node)
07375     {
07376         defaultOut(node);
07377     }
07378     public void outABlockStmtWithoutTrailingSubstmt(ABlockStmtWithoutTrailingSubstmt node)
07379     {
07380         defaultOut(node);
07381     }
07382     public void outABooleanLiteralLiteral(ABooleanLiteralLiteral node)
07383     {
07384         defaultOut(node);
07385     }
07386     public void outABooleanPrimitiveType(ABooleanPrimitiveType node)
07387     {
07388         defaultOut(node);
07389     }
07390     public void outABreakStmt(ABreakStmt node)
07391     {
07392         defaultOut(node);
07393     }
07394     public void outABreakStmtStmtWithoutTrailingSubstmt(ABreakStmtStmtWithoutTrailingSubstmt node)
07395     {
07396         defaultOut(node);
07397     }
07398     public void outAByteIntegralType(AByteIntegralType node)
07399     {
07400         defaultOut(node);
07401     }
07402     public void outABytePrimitiveType(ABytePrimitiveType node)
07403     {
07404         defaultOut(node);
07405     }
07406     public void outACaseSwitchLabel(ACaseSwitchLabel node)
07407     {
07408         defaultOut(node);
07409     }
07410     public void outACastExpUnaryExpNotPlusMinus(ACastExpUnaryExpNotPlusMinus node)
07411     {
07412         defaultOut(node);
07413     }
07414     public void outACatchClause(ACatchClause node)
07415     {
07416         defaultOut(node);
07417     }
07418     public void outACharacterLiteralLiteral(ACharacterLiteralLiteral node)
07419     {
07420         defaultOut(node);
07421     }
07422     public void outACharIntegralType(ACharIntegralType node)
07423     {
07424         defaultOut(node);
07425     }
07426     public void outACharPrimitiveType(ACharPrimitiveType node)
07427     {
07428         defaultOut(node);
07429     }
07430     public void outAClassBody(AClassBody node)
07431     {
07432         defaultOut(node);
07433     }
07434     public void outAClassClassBodyDeclaration(AClassClassBodyDeclaration node)
07435     {
07436         defaultOut(node);
07437     }
07438     public void outAClassDeclaration(AClassDeclaration node)
07439     {
07440         defaultOut(node);
07441     }
07442     public void outAClassDeclarationBlockedStmt(AClassDeclarationBlockedStmt node)
07443     {
07444         defaultOut(node);
07445     }
07446     public void outAClassDeclarationClassMemberDeclaration(AClassDeclarationClassMemberDeclaration node)
07447     {
07448         defaultOut(node);
07449     }
07450     public void outAClassDeclarationInterfaceMemberDeclaration(AClassDeclarationInterfaceMemberDeclaration node)
07451     {
07452         defaultOut(node);
07453     }
07454     public void outAClassInstanceCreationExpPrimaryNoNewArray(AClassInstanceCreationExpPrimaryNoNewArray node)
07455     {
07456         defaultOut(node);
07457     }
07458     public void outAClassInstanceCreationExpStmtExp(AClassInstanceCreationExpStmtExp node)
07459     {
07460         defaultOut(node);
07461     }
07462     public void outAClassMemberDeclarationClassBodyDeclaration(AClassMemberDeclarationClassBodyDeclaration node)
07463     {
07464         defaultOut(node);
07465     }
07466     public void outAClassOrInterfaceType(AClassOrInterfaceType node)
07467     {
07468         defaultOut(node);
07469     }
07470     public void outAClassOrInterfaceTypeArrayCreationExp(AClassOrInterfaceTypeArrayCreationExp node)
07471     {
07472         defaultOut(node);
07473     }
07474     public void outAClassOrInterfaceTypeExp(AClassOrInterfaceTypeExp node)
07475     {
07476         defaultOut(node);
07477     }
07478     public void outAClassOrInterfaceTypeReferenceType(AClassOrInterfaceTypeReferenceType node)
07479     {
07480         defaultOut(node);
07481     }
07482     public void outAClassType(AClassType node)
07483     {
07484         defaultOut(node);
07485     }
07486     public void outAClassTypeClassTypeList(AClassTypeClassTypeList node)
07487     {
07488         defaultOut(node);
07489     }
07490     public void outAClassTypeDeclaration(AClassTypeDeclaration node)
07491     {
07492         defaultOut(node);
07493     }
07494     public void outAClassTypeListClassTypeList(AClassTypeListClassTypeList node)
07495     {
07496         defaultOut(node);
07497     }
07498     public void outACompilationUnit(ACompilationUnit node)
07499     {
07500         defaultOut(node);
07501     }
07502     public void outAComplementUnaryExpNotPlusMinus(AComplementUnaryExpNotPlusMinus node)
07503     {
07504         defaultOut(node);
07505     }
07506     public void outAComplementUnaryOperator(AComplementUnaryOperator node)
07507     {
07508         defaultOut(node);
07509     }
07510     public void outAConditionalAndExpConditionalAndExp(AConditionalAndExpConditionalAndExp node)
07511     {
07512         defaultOut(node);
07513     }
07514     public void outAConditionalAndExpConditionalOrExp(AConditionalAndExpConditionalOrExp node)
07515     {
07516         defaultOut(node);
07517     }
07518     public void outAConditionalExpAssignmentExp(AConditionalExpAssignmentExp node)
07519     {
07520         defaultOut(node);
07521     }
07522     public void outAConditionalOrExpConditionalExp(AConditionalOrExpConditionalExp node)
07523     {
07524         defaultOut(node);
07525     }
07526     public void outAConditionalOrExpConditionalOrExp(AConditionalOrExpConditionalOrExp node)
07527     {
07528         defaultOut(node);
07529     }
07530     public void outAConstantDeclaration(AConstantDeclaration node)
07531     {
07532         defaultOut(node);
07533     }
07534     public void outAConstantDeclarationInterfaceMemberDeclaration(AConstantDeclarationInterfaceMemberDeclaration node)
07535     {
07536         defaultOut(node);
07537     }
07538     public void outAConstantExp(AConstantExp node)
07539     {
07540         defaultOut(node);
07541     }
07542     public void outAConstructorBody(AConstructorBody node)
07543     {
07544         defaultOut(node);
07545     }
07546     public void outAConstructorClassBodyDeclaration(AConstructorClassBodyDeclaration node)
07547     {
07548         defaultOut(node);
07549     }
07550     public void outAConstructorDeclaration(AConstructorDeclaration node)
07551     {
07552         defaultOut(node);
07553     }
07554     public void outAConstructorDeclarator(AConstructorDeclarator node)
07555     {
07556         defaultOut(node);
07557     }
07558     public void outAContinueStmt(AContinueStmt node)
07559     {
07560         defaultOut(node);
07561     }
07562     public void outAContinueStmtStmtWithoutTrailingSubstmt(AContinueStmtStmtWithoutTrailingSubstmt node)
07563     {
07564         defaultOut(node);
07565     }
07566     public void outADecimalIntegerLiteral(ADecimalIntegerLiteral node)
07567     {
07568         defaultOut(node);
07569     }
07570     public void outADecrementUnaryOperator(ADecrementUnaryOperator node)
07571     {
07572         defaultOut(node);
07573     }
07574     public void outADefaultSwitchLabel(ADefaultSwitchLabel node)
07575     {
07576         defaultOut(node);
07577     }
07578     public void outADim(ADim node)
07579     {
07580         defaultOut(node);
07581     }
07582     public void outADimExp(ADimExp node)
07583     {
07584         defaultOut(node);
07585     }
07586     public void outADivAssignAssignmentOperator(ADivAssignAssignmentOperator node)
07587     {
07588         defaultOut(node);
07589     }
07590     public void outADivBinaryOperator(ADivBinaryOperator node)
07591     {
07592         defaultOut(node);
07593     }
07594     public void outADivMultiplicativeExp(ADivMultiplicativeExp node)
07595     {
07596         defaultOut(node);
07597     }
07598     public void outADoStmt(ADoStmt node)
07599     {
07600         defaultOut(node);
07601     }
07602     public void outADoStmtStmtWithoutTrailingSubstmt(ADoStmtStmtWithoutTrailingSubstmt node)
07603     {
07604         defaultOut(node);
07605     }
07606     public void outADoubleFloatingPointType(ADoubleFloatingPointType node)
07607     {
07608         defaultOut(node);
07609     }
07610     public void outADoublePrimitiveType(ADoublePrimitiveType node)
07611     {
07612         defaultOut(node);
07613     }
07614     public void outAEmptyMethodBody(AEmptyMethodBody node)
07615     {
07616         defaultOut(node);
07617     }
07618     public void outAEmptyStmt(AEmptyStmt node)
07619     {
07620         defaultOut(node);
07621     }
07622     public void outAEmptyStmtStmtWithoutTrailingSubstmt(AEmptyStmtStmtWithoutTrailingSubstmt node)
07623     {
07624         defaultOut(node);
07625     }
07626     public void outAEmptyTypeDeclaration(AEmptyTypeDeclaration node)
07627     {
07628         defaultOut(node);
07629     }
07630     public void outAEqBinaryOperator(AEqBinaryOperator node)
07631     {
07632         defaultOut(node);
07633     }
07634     public void outAEqEqualityExp(AEqEqualityExp node)
07635     {
07636         defaultOut(node);
07637     }
07638     public void outAEqualityExpAndExp(AEqualityExpAndExp node)
07639     {
07640         defaultOut(node);
07641     }
07642     public void outAExclusiveOrExpExclusiveOrExp(AExclusiveOrExpExclusiveOrExp node)
07643     {
07644         defaultOut(node);
07645     }
07646     public void outAExclusiveOrExpInclusiveOrExp(AExclusiveOrExpInclusiveOrExp node)
07647     {
07648         defaultOut(node);
07649     }
07650     public void outAExpArgumentList(AExpArgumentList node)
07651     {
07652         defaultOut(node);
07653     }
07654     public void outAExpCastExp(AExpCastExp node)
07655     {
07656         defaultOut(node);
07657     }
07658     public void outAExpListForInit(AExpListForInit node)
07659     {
07660         defaultOut(node);
07661     }
07662     public void outAExpStmt(AExpStmt node)
07663     {
07664         defaultOut(node);
07665     }
07666     public void outAExpStmtStmtWithoutTrailingSubstmt(AExpStmtStmtWithoutTrailingSubstmt node)
07667     {
07668         defaultOut(node);
07669     }
07670     public void outAExpVariableInitializer(AExpVariableInitializer node)
07671     {
07672         defaultOut(node);
07673     }
07674     public void outAExtendsExtendsInterfaces(AExtendsExtendsInterfaces node)
07675     {
07676         defaultOut(node);
07677     }
07678     public void outAExtendsInterfacesExtendsInterfaces(AExtendsInterfacesExtendsInterfaces node)
07679     {
07680         defaultOut(node);
07681     }
07682     public void outAFalseBooleanLiteral(AFalseBooleanLiteral node)
07683     {
07684         defaultOut(node);
07685     }
07686     public void outAFieldAccessExp(AFieldAccessExp node)
07687     {
07688         defaultOut(node);
07689     }
07690     public void outAFieldAccessLeftHandSide(AFieldAccessLeftHandSide node)
07691     {
07692         defaultOut(node);
07693     }
07694     public void outAFieldAccessPrimaryNoNewArray(AFieldAccessPrimaryNoNewArray node)
07695     {
07696         defaultOut(node);
07697     }
07698     public void outAFieldClassBodyDeclaration(AFieldClassBodyDeclaration node)
07699     {
07700         defaultOut(node);
07701     }
07702     public void outAFieldDeclaration(AFieldDeclaration node)
07703     {
07704         defaultOut(node);
07705     }
07706     public void outAFieldDeclarationClassMemberDeclaration(AFieldDeclarationClassMemberDeclaration node)
07707     {
07708         defaultOut(node);
07709     }
07710     public void outAFinally(AFinally node)
07711     {
07712         defaultOut(node);
07713     }
07714     public void outAFinallyOneTryStmt(AFinallyOneTryStmt node)
07715     {
07716         defaultOut(node);
07717     }
07718     public void outAFinalModifier(AFinalModifier node)
07719     {
07720         defaultOut(node);
07721     }
07722     public void outAFloatFloatingPointType(AFloatFloatingPointType node)
07723     {
07724         defaultOut(node);
07725     }
07726     public void outAFloatingPointLiteralLiteral(AFloatingPointLiteralLiteral node)
07727     {
07728         defaultOut(node);
07729     }
07730     public void outAFloatingPointTypeNumericType(AFloatingPointTypeNumericType node)
07731     {
07732         defaultOut(node);
07733     }
07734     public void outAFloatPrimitiveType(AFloatPrimitiveType node)
07735     {
07736         defaultOut(node);
07737     }
07738     public void outAFormalParameter(AFormalParameter node)
07739     {
07740         defaultOut(node);
07741     }
07742     public void outAFormalParameterFormalParameterList(AFormalParameterFormalParameterList node)
07743     {
07744         defaultOut(node);
07745     }
07746     public void outAFormalParameterListFormalParameterList(AFormalParameterListFormalParameterList node)
07747     {
07748         defaultOut(node);
07749     }
07750     public void outAForStmt(AForStmt node)
07751     {
07752         defaultOut(node);
07753     }
07754     public void outAForStmtNoShortIf(AForStmtNoShortIf node)
07755     {
07756         defaultOut(node);
07757     }
07758     public void outAForStmtNoShortIfStmtNoShortIf(AForStmtNoShortIfStmtNoShortIf node)
07759     {
07760         defaultOut(node);
07761     }
07762     public void outAForStmtStmt(AForStmtStmt node)
07763     {
07764         defaultOut(node);
07765     }
07766     public void outAForUpdate(AForUpdate node)
07767     {
07768         defaultOut(node);
07769     }
07770     public void outAGtBinaryOperator(AGtBinaryOperator node)
07771     {
07772         defaultOut(node);
07773     }
07774     public void outAGteqBinaryOperator(AGteqBinaryOperator node)
07775     {
07776         defaultOut(node);
07777     }
07778     public void outAGteqRelationalExp(AGteqRelationalExp node)
07779     {
07780         defaultOut(node);
07781     }
07782     public void outAGtRelationalExp(AGtRelationalExp node)
07783     {
07784         defaultOut(node);
07785     }
07786     public void outAHexIntegerLiteral(AHexIntegerLiteral node)
07787     {
07788         defaultOut(node);
07789     }
07790     public void outAIdVariableDeclarator(AIdVariableDeclarator node)
07791     {
07792         defaultOut(node);
07793     }
07794     public void outAIfStmt(AIfStmt node)
07795     {
07796         defaultOut(node);
07797     }
07798     public void outAIfThenElseStmt(AIfThenElseStmt node)
07799     {
07800         defaultOut(node);
07801     }
07802     public void outAIfThenElseStmtNoShortIf(AIfThenElseStmtNoShortIf node)
07803     {
07804         defaultOut(node);
07805     }
07806     public void outAIfThenElseStmtNoShortIfStmtNoShortIf(AIfThenElseStmtNoShortIfStmtNoShortIf node)
07807     {
07808         defaultOut(node);
07809     }
07810     public void outAIfThenElseStmtStmt(AIfThenElseStmtStmt node)
07811     {
07812         defaultOut(node);
07813     }
07814     public void outAIfThenStmt(AIfThenStmt node)
07815     {
07816         defaultOut(node);
07817     }
07818     public void outAIfThenStmtStmt(AIfThenStmtStmt node)
07819     {
07820         defaultOut(node);
07821     }
07822     public void outAInclusiveOrExpConditionalAndExp(AInclusiveOrExpConditionalAndExp node)
07823     {
07824         defaultOut(node);
07825     }
07826     public void outAInclusiveOrExpInclusiveOrExp(AInclusiveOrExpInclusiveOrExp node)
07827     {
07828         defaultOut(node);
07829     }
07830     public void outAIncrementUnaryOperator(AIncrementUnaryOperator node)
07831     {
07832         defaultOut(node);
07833     }
07834     public void outAInitClassInterfaceArrayCreationExp(AInitClassInterfaceArrayCreationExp node)
07835     {
07836         defaultOut(node);
07837     }
07838     public void outAInitClassInterfaceExp(AInitClassInterfaceExp node)
07839     {
07840         defaultOut(node);
07841     }
07842     public void outAInitPrimitiveArrayCreationExp(AInitPrimitiveArrayCreationExp node)
07843     {
07844         defaultOut(node);
07845     }
07846     public void outAInitPrimitiveExp(AInitPrimitiveExp node)
07847     {
07848         defaultOut(node);
07849     }
07850     public void outAInstanceofExp(AInstanceofExp node)
07851     {
07852         defaultOut(node);
07853     }
07854     public void outAInstanceofRelationalExp(AInstanceofRelationalExp node)
07855     {
07856         defaultOut(node);
07857     }
07858     public void outAIntegerLiteralLiteral(AIntegerLiteralLiteral node)
07859     {
07860         defaultOut(node);
07861     }
07862     public void outAIntegralTypeNumericType(AIntegralTypeNumericType node)
07863     {
07864         defaultOut(node);
07865     }
07866     public void outAInterfaceBody(AInterfaceBody node)
07867     {
07868         defaultOut(node);
07869     }
07870     public void outAInterfaceClassBodyDeclaration(AInterfaceClassBodyDeclaration node)
07871     {
07872         defaultOut(node);
07873     }
07874     public void outAInterfaceDeclaration(AInterfaceDeclaration node)
07875     {
07876         defaultOut(node);
07877     }
07878     public void outAInterfaceDeclarationClassMemberDeclaration(AInterfaceDeclarationClassMemberDeclaration node)
07879     {
07880         defaultOut(node);
07881     }
07882     public void outAInterfaceDeclarationInterfaceMemberDeclaration(AInterfaceDeclarationInterfaceMemberDeclaration node)
07883     {
07884         defaultOut(node);
07885     }
07886     public void outAInterfaces(AInterfaces node)
07887     {
07888         defaultOut(node);
07889     }
07890     public void outAInterfaceType(AInterfaceType node)
07891     {
07892         defaultOut(node);
07893     }
07894     public void outAInterfaceTypeDeclaration(AInterfaceTypeDeclaration node)
07895     {
07896         defaultOut(node);
07897     }
07898     public void outAInterfaceTypeInterfaceTypeList(AInterfaceTypeInterfaceTypeList node)
07899     {
07900         defaultOut(node);
07901     }
07902     public void outAInterfaceTypeListInterfaceTypeList(AInterfaceTypeListInterfaceTypeList node)
07903     {
07904         defaultOut(node);
07905     }
07906     public void outAIntIntegralType(AIntIntegralType node)
07907     {
07908         defaultOut(node);
07909     }
07910     public void outAIntPrimitiveType(AIntPrimitiveType node)
07911     {
07912         defaultOut(node);
07913     }
07914     public void outALabeledStmt(ALabeledStmt node)
07915     {
07916         defaultOut(node);
07917     }
07918     public void outALabeledStmtNoShortIf(ALabeledStmtNoShortIf node)
07919     {
07920         defaultOut(node);
07921     }
07922     public void outALabeledStmtNoShortIfStmtNoShortIf(ALabeledStmtNoShortIfStmtNoShortIf node)
07923     {
07924         defaultOut(node);
07925     }
07926     public void outALabeledStmtStmt(ALabeledStmtStmt node)
07927     {
07928         defaultOut(node);
07929     }
07930     public void outALabelStmt(ALabelStmt node)
07931     {
07932         defaultOut(node);
07933     }
07934     public void outALiteralExp(ALiteralExp node)
07935     {
07936         defaultOut(node);
07937     }
07938     public void outALiteralPrimaryNoNewArray(ALiteralPrimaryNoNewArray node)
07939     {
07940         defaultOut(node);
07941     }
07942     public void outALocalVariableDeclaration(ALocalVariableDeclaration node)
07943     {
07944         defaultOut(node);
07945     }
07946     public void outALocalVariableDeclarationForInit(ALocalVariableDeclarationForInit node)
07947     {
07948         defaultOut(node);
07949     }
07950     public void outALocalVariableDeclarationInBlockedStmt(ALocalVariableDeclarationInBlockedStmt node)
07951     {
07952         defaultOut(node);
07953     }
07954     public void outALocalVariableDeclarationStmt(ALocalVariableDeclarationStmt node)
07955     {
07956         defaultOut(node);
07957     }
07958     public void outALocalVariableDeclarationStmtBlockedStmt(ALocalVariableDeclarationStmtBlockedStmt node)
07959     {
07960         defaultOut(node);
07961     }
07962     public void outALongIntegralType(ALongIntegralType node)
07963     {
07964         defaultOut(node);
07965     }
07966     public void outALongPrimitiveType(ALongPrimitiveType node)
07967     {
07968         defaultOut(node);
07969     }
07970     public void outALParPrimaryNoNewArray(ALParPrimaryNoNewArray node)
07971     {
07972         defaultOut(node);
07973     }
07974     public void outALtBinaryOperator(ALtBinaryOperator node)
07975     {
07976         defaultOut(node);
07977     }
07978     public void outALteqBinaryOperator(ALteqBinaryOperator node)
07979     {
07980         defaultOut(node);
07981     }
07982     public void outALteqRelationalExp(ALteqRelationalExp node)
07983     {
07984         defaultOut(node);
07985     }
07986     public void outALtRelationalExp(ALtRelationalExp node)
07987     {
07988         defaultOut(node);
07989     }
07990     public void outAMethodClassBodyDeclaration(AMethodClassBodyDeclaration node)
07991     {
07992         defaultOut(node);
07993     }
07994     public void outAMethodDeclaration(AMethodDeclaration node)
07995     {
07996         defaultOut(node);
07997     }
07998     public void outAMethodDeclarationClassMemberDeclaration(AMethodDeclarationClassMemberDeclaration node)
07999     {
08000         defaultOut(node);
08001     }
08002     public void outAMethodDeclarator(AMethodDeclarator node)
08003     {
08004         defaultOut(node);
08005     }
08006     public void outAMethodInvocationPrimaryNoNewArray(AMethodInvocationPrimaryNoNewArray node)
08007     {
08008         defaultOut(node);
08009     }
08010     public void outAMethodInvocationStmtExp(AMethodInvocationStmtExp node)
08011     {
08012         defaultOut(node);
08013     }
08014     public void outAMinusAdditiveExp(AMinusAdditiveExp node)
08015     {
08016         defaultOut(node);
08017     }
08018     public void outAMinusAssignAssignmentOperator(AMinusAssignAssignmentOperator node)
08019     {
08020         defaultOut(node);
08021     }
08022     public void outAMinusBinaryOperator(AMinusBinaryOperator node)
08023     {
08024         defaultOut(node);
08025     }
08026     public void outAMinusUnaryExp(AMinusUnaryExp node)
08027     {
08028         defaultOut(node);
08029     }
08030     public void outAMinusUnaryOperator(AMinusUnaryOperator node)
08031     {
08032         defaultOut(node);
08033     }
08034     public void outAModAssignAssignmentOperator(AModAssignAssignmentOperator node)
08035     {
08036         defaultOut(node);
08037     }
08038     public void outAModBinaryOperator(AModBinaryOperator node)
08039     {
08040         defaultOut(node);
08041     }
08042     public void outAModMultiplicativeExp(AModMultiplicativeExp node)
08043     {
08044         defaultOut(node);
08045     }
08046     public void outAMultiplicativeExpAdditiveExp(AMultiplicativeExpAdditiveExp node)
08047     {
08048         defaultOut(node);
08049     }
08050     public void outANameArrayAccess(ANameArrayAccess node)
08051     {
08052         defaultOut(node);
08053     }
08054     public void outANameArrayType(ANameArrayType node)
08055     {
08056         defaultOut(node);
08057     }
08058     public void outANameCastExp(ANameCastExp node)
08059     {
08060         defaultOut(node);
08061     }
08062     public void outANamedTypeExp(ANamedTypeExp node)
08063     {
08064         defaultOut(node);
08065     }
08066     public void outANameExp(ANameExp node)
08067     {
08068         defaultOut(node);
08069     }
08070     public void outANameLeftHandSide(ANameLeftHandSide node)
08071     {
08072         defaultOut(node);
08073     }
08074     public void outANameMethodInvocation(ANameMethodInvocation node)
08075     {
08076         defaultOut(node);
08077     }
08078     public void outANameMethodInvocationExp(ANameMethodInvocationExp node)
08079     {
08080         defaultOut(node);
08081     }
08082     public void outANamePostfixExp(ANamePostfixExp node)
08083     {
08084         defaultOut(node);
08085     }
08086     public void outANameReferenceType(ANameReferenceType node)
08087     {
08088         defaultOut(node);
08089     }
08090     public void outANativeModifier(ANativeModifier node)
08091     {
08092         defaultOut(node);
08093     }
08094     public void outANeqBinaryOperator(ANeqBinaryOperator node)
08095     {
08096         defaultOut(node);
08097     }
08098     public void outANeqEqualityExp(ANeqEqualityExp node)
08099     {
08100         defaultOut(node);
08101     }
08102     public void outANotPlusMinusUnaryExp(ANotPlusMinusUnaryExp node)
08103     {
08104         defaultOut(node);
08105     }
08106     public void outANullLiteral(ANullLiteral node)
08107     {
08108         defaultOut(node);
08109     }
08110     public void outANullLiteralLiteral(ANullLiteralLiteral node)
08111     {
08112         defaultOut(node);
08113     }
08114     public void outANumericTypePrimitiveType(ANumericTypePrimitiveType node)
08115     {
08116         defaultOut(node);
08117     }
08118     public void outAOctalIntegerLiteral(AOctalIntegerLiteral node)
08119     {
08120         defaultOut(node);
08121     }
08122     public void outAOldAbstractMethodDeclarationInterfaceMemberDeclaration(AOldAbstractMethodDeclarationInterfaceMemberDeclaration node)
08123     {
08124         defaultOut(node);
08125     }
08126     public void outAOldArrayInitializer(AOldArrayInitializer node)
08127     {
08128         defaultOut(node);
08129     }
08130     public void outAOldCaseSwitchLabel(AOldCaseSwitchLabel node)
08131     {
08132         defaultOut(node);
08133     }
08134     public void outAOldCompilationUnit(AOldCompilationUnit node)
08135     {
08136         defaultOut(node);
08137     }
08138     public void outAOldConstantDeclarationInterfaceMemberDeclaration(AOldConstantDeclarationInterfaceMemberDeclaration node)
08139     {
08140         defaultOut(node);
08141     }
08142     public void outAOldConstructorDeclarator(AOldConstructorDeclarator node)
08143     {
08144         defaultOut(node);
08145     }
08146     public void outAOldExp(AOldExp node)
08147     {
08148         defaultOut(node);
08149     }
08150     public void outAOldExpCastExp(AOldExpCastExp node)
08151     {
08152         defaultOut(node);
08153     }
08154     public void outAOldFieldDeclaration(AOldFieldDeclaration node)
08155     {
08156         defaultOut(node);
08157     }
08158     public void outAOldInterfaceDeclaration(AOldInterfaceDeclaration node)
08159     {
08160         defaultOut(node);
08161     }
08162     public void outAOldInterfaces(AOldInterfaces node)
08163     {
08164         defaultOut(node);
08165     }
08166     public void outAOldLocalVariableDeclaration(AOldLocalVariableDeclaration node)
08167     {
08168         defaultOut(node);
08169     }
08170     public void outAOldMethodDeclarator(AOldMethodDeclarator node)
08171     {
08172         defaultOut(node);
08173     }
08174     public void outAOldNameCastExp(AOldNameCastExp node)
08175     {
08176         defaultOut(node);
08177     }
08178     public void outAOldNamedTypePrimaryNoNewArray(AOldNamedTypePrimaryNoNewArray node)
08179     {
08180         defaultOut(node);
08181     }
08182     public void outAOldPrimaryFieldAccess(AOldPrimaryFieldAccess node)
08183     {
08184         defaultOut(node);
08185     }
08186     public void outAOldPrimaryNoNewArrayArrayAccess(AOldPrimaryNoNewArrayArrayAccess node)
08187     {
08188         defaultOut(node);
08189     }
08190     public void outAOldPrimitiveTypeCastExp(AOldPrimitiveTypeCastExp node)
08191     {
08192         defaultOut(node);
08193     }
08194     public void outAOldPrimitiveTypePrimaryNoNewArray(AOldPrimitiveTypePrimaryNoNewArray node)
08195     {
08196         defaultOut(node);
08197     }
08198     public void outAOldQualifiedClassInstanceCreationExp(AOldQualifiedClassInstanceCreationExp node)
08199     {
08200         defaultOut(node);
08201     }
08202     public void outAOldQualifiedConstructorInvocation(AOldQualifiedConstructorInvocation node)
08203     {
08204         defaultOut(node);
08205     }
08206     public void outAOldSimpleClassInstanceCreationExp(AOldSimpleClassInstanceCreationExp node)
08207     {
08208         defaultOut(node);
08209     }
08210     public void outAOldStaticInitializerClassBodyDeclaration(AOldStaticInitializerClassBodyDeclaration node)
08211     {
08212         defaultOut(node);
08213     }
08214     public void outAOldSuper(AOldSuper node)
08215     {
08216         defaultOut(node);
08217     }
08218     public void outAOldSuperConstructorInvocation(AOldSuperConstructorInvocation node)
08219     {
08220         defaultOut(node);
08221     }
08222     public void outAOldThisConstructorInvocation(AOldThisConstructorInvocation node)
08223     {
08224         defaultOut(node);
08225     }
08226     public void outAOldThrows(AOldThrows node)
08227     {
08228         defaultOut(node);
08229     }
08230     public void outAOneBreakStmt(AOneBreakStmt node)
08231     {
08232         defaultOut(node);
08233     }
08234     public void outAOneContinueStmt(AOneContinueStmt node)
08235     {
08236         defaultOut(node);
08237     }
08238     public void outAOneDoStmt(AOneDoStmt node)
08239     {
08240         defaultOut(node);
08241     }
08242     public void outAOneForStmt(AOneForStmt node)
08243     {
08244         defaultOut(node);
08245     }
08246     public void outAOneQualifiedName(AOneQualifiedName node)
08247     {
08248         defaultOut(node);
08249     }
08250     public void outAOneReturnStmt(AOneReturnStmt node)
08251     {
08252         defaultOut(node);
08253     }
08254     public void outAOneSimpleName(AOneSimpleName node)
08255     {
08256         defaultOut(node);
08257     }
08258     public void outAOneSingleTypeImportDeclaration(AOneSingleTypeImportDeclaration node)
08259     {
08260         defaultOut(node);
08261     }
08262     public void outAOneSwitchStmt(AOneSwitchStmt node)
08263     {
08264         defaultOut(node);
08265     }
08266     public void outAOneSynchronizedStmt(AOneSynchronizedStmt node)
08267     {
08268         defaultOut(node);
08269     }
08270     public void outAOneThrowStmt(AOneThrowStmt node)
08271     {
08272         defaultOut(node);
08273     }
08274     public void outAOneTypeImportOnDemandDeclaration(AOneTypeImportOnDemandDeclaration node)
08275     {
08276         defaultOut(node);
08277     }
08278     public void outAOneWhileStmt(AOneWhileStmt node)
08279     {
08280         defaultOut(node);
08281     }
08282     public void outAOrBinaryOperator(AOrBinaryOperator node)
08283     {
08284         defaultOut(node);
08285     }
08286     public void outAOriginalExpStmt(AOriginalExpStmt node)
08287     {
08288         defaultOut(node);
08289     }
08290     public void outAPackageDeclaration(APackageDeclaration node)
08291     {
08292         defaultOut(node);
08293     }
08294     public void outAParExp(AParExp node)
08295     {
08296         defaultOut(node);
08297     }
08298     public void outAPlusAdditiveExp(APlusAdditiveExp node)
08299     {
08300         defaultOut(node);
08301     }
08302     public void outAPlusAssignAssignmentOperator(APlusAssignAssignmentOperator node)
08303     {
08304         defaultOut(node);
08305     }
08306     public void outAPlusBinaryOperator(APlusBinaryOperator node)
08307     {
08308         defaultOut(node);
08309     }
08310     public void outAPlusUnaryExp(APlusUnaryExp node)
08311     {
08312         defaultOut(node);
08313     }
08314     public void outAPlusUnaryOperator(APlusUnaryOperator node)
08315     {
08316         defaultOut(node);
08317     }
08318     public void outAPostDecrementExp(APostDecrementExp node)
08319     {
08320         defaultOut(node);
08321     }
08322     public void outAPostDecrementExpPostfixExp(APostDecrementExpPostfixExp node)
08323     {
08324         defaultOut(node);
08325     }
08326     public void outAPostDecrementExpr(APostDecrementExpr node)
08327     {
08328         defaultOut(node);
08329     }
08330     public void outAPostDecrementExpStmtExp(APostDecrementExpStmtExp node)
08331     {
08332         defaultOut(node);
08333     }
08334     public void outAPostfixExpUnaryExpNotPlusMinus(APostfixExpUnaryExpNotPlusMinus node)
08335     {
08336         defaultOut(node);
08337     }
08338     public void outAPostIncrementExp(APostIncrementExp node)
08339     {
08340         defaultOut(node);
08341     }
08342     public void outAPostIncrementExpPostfixExp(APostIncrementExpPostfixExp node)
08343     {
08344         defaultOut(node);
08345     }
08346     public void outAPostIncrementExpr(APostIncrementExpr node)
08347     {
08348         defaultOut(node);
08349     }
08350     public void outAPostIncrementExpStmtExp(APostIncrementExpStmtExp node)
08351     {
08352         defaultOut(node);
08353     }
08354     public void outAPreDecrementExp(APreDecrementExp node)
08355     {
08356         defaultOut(node);
08357     }
08358     public void outAPreDecrementExpStmtExp(APreDecrementExpStmtExp node)
08359     {
08360         defaultOut(node);
08361     }
08362     public void outAPreDecrementExpUnaryExp(APreDecrementExpUnaryExp node)
08363     {
08364         defaultOut(node);
08365     }
08366     public void outAPreIncrementExp(APreIncrementExp node)
08367     {
08368         defaultOut(node);
08369     }
08370     public void outAPreIncrementExpStmtExp(APreIncrementExpStmtExp node)
08371     {
08372         defaultOut(node);
08373     }
08374     public void outAPreIncrementExpUnaryExp(APreIncrementExpUnaryExp node)
08375     {
08376         defaultOut(node);
08377     }
08378     public void outAPrimaryFieldAccess(APrimaryFieldAccess node)
08379     {
08380         defaultOut(node);
08381     }
08382     public void outAPrimaryMethodInvocation(APrimaryMethodInvocation node)
08383     {
08384         defaultOut(node);
08385     }
08386     public void outAPrimaryMethodInvocationExp(APrimaryMethodInvocationExp node)
08387     {
08388         defaultOut(node);
08389     }
08390     public void outAPrimaryNoNewArrayArrayAccess(APrimaryNoNewArrayArrayAccess node)
08391     {
08392         defaultOut(node);
08393     }
08394     public void outAPrimaryNoNewArrayPrimary(APrimaryNoNewArrayPrimary node)
08395     {
08396         defaultOut(node);
08397     }
08398     public void outAPrimaryPostfixExp(APrimaryPostfixExp node)
08399     {
08400         defaultOut(node);
08401     }
08402     public void outAPrimitiveArrayType(APrimitiveArrayType node)
08403     {
08404         defaultOut(node);
08405     }
08406     public void outAPrimitiveType(APrimitiveType node)
08407     {
08408         defaultOut(node);
08409     }
08410     public void outAPrimitiveTypeArrayCreationExp(APrimitiveTypeArrayCreationExp node)
08411     {
08412         defaultOut(node);
08413     }
08414     public void outAPrimitiveTypeArrayExp(APrimitiveTypeArrayExp node)
08415     {
08416         defaultOut(node);
08417     }
08418     public void outAPrimitiveTypeCastExp(APrimitiveTypeCastExp node)
08419     {
08420         defaultOut(node);
08421     }
08422     public void outAPrimitiveTypePrimaryExp(APrimitiveTypePrimaryExp node)
08423     {
08424         defaultOut(node);
08425     }
08426     public void outAPrivateModifier(APrivateModifier node)
08427     {
08428         defaultOut(node);
08429     }
08430     public void outAProtectedModifier(AProtectedModifier node)
08431     {
08432         defaultOut(node);
08433     }
08434     public void outAPublicModifier(APublicModifier node)
08435     {
08436         defaultOut(node);
08437     }
08438     public void outAQualifiedClassInstanceCreationExp(AQualifiedClassInstanceCreationExp node)
08439     {
08440         defaultOut(node);
08441     }
08442     public void outAQualifiedConstructorInvocation(AQualifiedConstructorInvocation node)
08443     {
08444         defaultOut(node);
08445     }
08446     public void outAQualifiedName(AQualifiedName node)
08447     {
08448         defaultOut(node);
08449     }
08450     public void outAQualifiedNameName(AQualifiedNameName node)
08451     {
08452         defaultOut(node);
08453     }
08454     public void outAQualifiedThisExp(AQualifiedThisExp node)
08455     {
08456         defaultOut(node);
08457     }
08458     public void outAQualifiedThisPrimaryNoNewArray(AQualifiedThisPrimaryNoNewArray node)
08459     {
08460         defaultOut(node);
08461     }
08462     public void outAQuestionConditionalExp(AQuestionConditionalExp node)
08463     {
08464         defaultOut(node);
08465     }
08466     public void outAQuestionExp(AQuestionExp node)
08467     {
08468         defaultOut(node);
08469     }
08470     public void outAReferenceType(AReferenceType node)
08471     {
08472         defaultOut(node);
08473     }
08474     public void outARelationalExpEqualityExp(ARelationalExpEqualityExp node)
08475     {
08476         defaultOut(node);
08477     }
08478     public void outAReturnStmt(AReturnStmt node)
08479     {
08480         defaultOut(node);
08481     }
08482     public void outAReturnStmtStmtWithoutTrailingSubstmt(AReturnStmtStmtWithoutTrailingSubstmt node)
08483     {
08484         defaultOut(node);
08485     }
08486     public void outASemicolonStmt(ASemicolonStmt node)
08487     {
08488         defaultOut(node);
08489     }
08490     public void outAShiftExpRelationalExp(AShiftExpRelationalExp node)
08491     {
08492         defaultOut(node);
08493     }
08494     public void outAShiftLeftAssignAssignmentOperator(AShiftLeftAssignAssignmentOperator node)
08495     {
08496         defaultOut(node);
08497     }
08498     public void outAShiftLeftBinaryOperator(AShiftLeftBinaryOperator node)
08499     {
08500         defaultOut(node);
08501     }
08502     public void outAShiftLeftShiftExp(AShiftLeftShiftExp node)
08503     {
08504         defaultOut(node);
08505     }
08506     public void outAShortIntegralType(AShortIntegralType node)
08507     {
08508         defaultOut(node);
08509     }
08510     public void outAShortPrimitiveType(AShortPrimitiveType node)
08511     {
08512         defaultOut(node);
08513     }
08514     public void outASignedShiftRightAssignAssignmentOperator(ASignedShiftRightAssignAssignmentOperator node)
08515     {
08516         defaultOut(node);
08517     }
08518     public void outASignedShiftRightBinaryOperator(ASignedShiftRightBinaryOperator node)
08519     {
08520         defaultOut(node);
08521     }
08522     public void outASignedShiftRightShiftExp(ASignedShiftRightShiftExp node)
08523     {
08524         defaultOut(node);
08525     }
08526     public void outASimpleClassInstanceCreationExp(ASimpleClassInstanceCreationExp node)
08527     {
08528         defaultOut(node);
08529     }
08530     public void outASimpleName(ASimpleName node)
08531     {
08532         defaultOut(node);
08533     }
08534     public void outASimpleNameName(ASimpleNameName node)
08535     {
08536         defaultOut(node);
08537     }
08538     public void outASingleTypeImportDeclaration(ASingleTypeImportDeclaration node)
08539     {
08540         defaultOut(node);
08541     }
08542     public void outASingleTypeImportDeclarationImportDeclaration(ASingleTypeImportDeclarationImportDeclaration node)
08543     {
08544         defaultOut(node);
08545     }
08546     public void outAStarAssignAssignmentOperator(AStarAssignAssignmentOperator node)
08547     {
08548         defaultOut(node);
08549     }
08550     public void outAStarBinaryOperator(AStarBinaryOperator node)
08551     {
08552         defaultOut(node);
08553     }
08554     public void outAStarMultiplicativeExp(AStarMultiplicativeExp node)
08555     {
08556         defaultOut(node);
08557     }
08558     public void outAStaticInitializer(AStaticInitializer node)
08559     {
08560         defaultOut(node);
08561     }
08562     public void outAStaticInitializerClassBodyDeclaration(AStaticInitializerClassBodyDeclaration node)
08563     {
08564         defaultOut(node);
08565     }
08566     public void outAStaticModifier(AStaticModifier node)
08567     {
08568         defaultOut(node);
08569     }
08570     public void outAStmtBlockedStmt(AStmtBlockedStmt node)
08571     {
08572         defaultOut(node);
08573     }
08574     public void outAStmtExpListForInit(AStmtExpListForInit node)
08575     {
08576         defaultOut(node);
08577     }
08578     public void outAStmtExpListStmtExpList(AStmtExpListStmtExpList node)
08579     {
08580         defaultOut(node);
08581     }
08582     public void outAStmtExpStmtExpList(AStmtExpStmtExpList node)
08583     {
08584         defaultOut(node);
08585     }
08586     public void outAStmtWithoutTrailingSubstmtStmt(AStmtWithoutTrailingSubstmtStmt node)
08587     {
08588         defaultOut(node);
08589     }
08590     public void outAStmtWithoutTrailingSubstmtStmtNoShortIf(AStmtWithoutTrailingSubstmtStmtNoShortIf node)
08591     {
08592         defaultOut(node);
08593     }
08594     public void outAStringLiteralLiteral(AStringLiteralLiteral node)
08595     {
08596         defaultOut(node);
08597     }
08598     public void outASuper(ASuper node)
08599     {
08600         defaultOut(node);
08601     }
08602     public void outASuperConstructorInvocation(ASuperConstructorInvocation node)
08603     {
08604         defaultOut(node);
08605     }
08606     public void outASuperFieldAccess(ASuperFieldAccess node)
08607     {
08608         defaultOut(node);
08609     }
08610     public void outASuperMethodInvocation(ASuperMethodInvocation node)
08611     {
08612         defaultOut(node);
08613     }
08614     public void outASuperMethodInvocationExp(ASuperMethodInvocationExp node)
08615     {
08616         defaultOut(node);
08617     }
08618     public void outASwitchBlockStmtGroup(ASwitchBlockStmtGroup node)
08619     {
08620         defaultOut(node);
08621     }
08622     public void outASwitchStmt(ASwitchStmt node)
08623     {
08624         defaultOut(node);
08625     }
08626     public void outASwitchStmtStmtWithoutTrailingSubstmt(ASwitchStmtStmtWithoutTrailingSubstmt node)
08627     {
08628         defaultOut(node);
08629     }
08630     public void outASynchronizedModifier(ASynchronizedModifier node)
08631     {
08632         defaultOut(node);
08633     }
08634     public void outASynchronizedStmt(ASynchronizedStmt node)
08635     {
08636         defaultOut(node);
08637     }
08638     public void outASynchronizedStmtStmtWithoutTrailingSubstmt(ASynchronizedStmtStmtWithoutTrailingSubstmt node)
08639     {
08640         defaultOut(node);
08641     }
08642     public void outAThisConstructorInvocation(AThisConstructorInvocation node)
08643     {
08644         defaultOut(node);
08645     }
08646     public void outAThisExp(AThisExp node)
08647     {
08648         defaultOut(node);
08649     }
08650     public void outAThisPrimaryNoNewArray(AThisPrimaryNoNewArray node)
08651     {
08652         defaultOut(node);
08653     }
08654     public void outAThrows(AThrows node)
08655     {
08656         defaultOut(node);
08657     }
08658     public void outAThrowStmt(AThrowStmt node)
08659     {
08660         defaultOut(node);
08661     }
08662     public void outAThrowStmtStmtWithoutTrailingSubstmt(AThrowStmtStmtWithoutTrailingSubstmt node)
08663     {
08664         defaultOut(node);
08665     }
08666     public void outATransientModifier(ATransientModifier node)
08667     {
08668         defaultOut(node);
08669     }
08670     public void outATrueBooleanLiteral(ATrueBooleanLiteral node)
08671     {
08672         defaultOut(node);
08673     }
08674     public void outATryFinallyStmt(ATryFinallyStmt node)
08675     {
08676         defaultOut(node);
08677     }
08678     public void outATryOneTryStmt(ATryOneTryStmt node)
08679     {
08680         defaultOut(node);
08681     }
08682     public void outATryStmt(ATryStmt node)
08683     {
08684         defaultOut(node);
08685     }
08686     public void outATryStmtStmtWithoutTrailingSubstmt(ATryStmtStmtWithoutTrailingSubstmt node)
08687     {
08688         defaultOut(node);
08689     }
08690     public void outATypedMethodHeader(ATypedMethodHeader node)
08691     {
08692         defaultOut(node);
08693     }
08694     public void outATypeImportOnDemandDeclarationImportDeclaration(ATypeImportOnDemandDeclarationImportDeclaration node)
08695     {
08696         defaultOut(node);
08697     }
08698     public void outATypeOnDemandImportDeclaration(ATypeOnDemandImportDeclaration node)
08699     {
08700         defaultOut(node);
08701     }
08702     public void outAUnaryExp(AUnaryExp node)
08703     {
08704         defaultOut(node);
08705     }
08706     public void outAUnaryExpMultiplicativeExp(AUnaryExpMultiplicativeExp node)
08707     {
08708         defaultOut(node);
08709     }
08710     public void outAUnsignedShiftRightAssignAssignmentOperator(AUnsignedShiftRightAssignAssignmentOperator node)
08711     {
08712         defaultOut(node);
08713     }
08714     public void outAUnsignedShiftRightBinaryOperator(AUnsignedShiftRightBinaryOperator node)
08715     {
08716         defaultOut(node);
08717     }
08718     public void outAUnsignedShiftRightShiftExp(AUnsignedShiftRightShiftExp node)
08719     {
08720         defaultOut(node);
08721     }
08722     public void outAVariableDeclaratorId(AVariableDeclaratorId node)
08723     {
08724         defaultOut(node);
08725     }
08726     public void outAVariableDeclaratorsVariableDeclarators(AVariableDeclaratorsVariableDeclarators node)
08727     {
08728         defaultOut(node);
08729     }
08730     public void outAVariableDeclaratorVariableDeclarators(AVariableDeclaratorVariableDeclarators node)
08731     {
08732         defaultOut(node);
08733     }
08734     public void outAVariableInitializersVariableInitializers(AVariableInitializersVariableInitializers node)
08735     {
08736         defaultOut(node);
08737     }
08738     public void outAVariableInitializerVariableInitializers(AVariableInitializerVariableInitializers node)
08739     {
08740         defaultOut(node);
08741     }
08742     public void outAVoidExp(AVoidExp node)
08743     {
08744         defaultOut(node);
08745     }
08746     public void outAVoidMethodHeader(AVoidMethodHeader node)
08747     {
08748         defaultOut(node);
08749     }
08750     public void outAVoidPrimaryNoNewArray(AVoidPrimaryNoNewArray node)
08751     {
08752         defaultOut(node);
08753     }
08754     public void outAVolatileModifier(AVolatileModifier node)
08755     {
08756         defaultOut(node);
08757     }
08758     public void outAWhileStmt(AWhileStmt node)
08759     {
08760         defaultOut(node);
08761     }
08762     public void outAWhileStmtNoShortIf(AWhileStmtNoShortIf node)
08763     {
08764         defaultOut(node);
08765     }
08766     public void outAWhileStmtNoShortIfStmtNoShortIf(AWhileStmtNoShortIfStmtNoShortIf node)
08767     {
08768         defaultOut(node);
08769     }
08770     public void outAWhileStmtStmt(AWhileStmtStmt node)
08771     {
08772         defaultOut(node);
08773     }
08774     public void outStart(Start node)
08775     {
08776         defaultOut(node);
08777     }
08778 }