DepthFirstAdapter.java Source File

00001 package edu.ksu.cis.bandera.specification.predicate.analysis;
00002 
00003 /* This file was generated by SableCC (http://www.sable.mcgill.ca/sablecc/). */
00004 
00005 import java.util.*;
00006 import edu.ksu.cis.bandera.specification.predicate.node.*;
00007 
00008 public class DepthFirstAdapter extends AnalysisAdapter
00009 {
00010     public void caseAAddExpShiftExp(AAddExpShiftExp node)
00011     {
00012         inAAddExpShiftExp(node);
00013         if(node.getAddExp() != null)
00014         {
00015             node.getAddExp().apply(this);
00016         }
00017         outAAddExpShiftExp(node);
00018     }
00019     public void caseAAndAndExp(AAndAndExp node)
00020     {
00021         inAAndAndExp(node);
00022         if(node.getAndExp() != null)
00023         {
00024             node.getAndExp().apply(this);
00025         }
00026         if(node.getAnd() != null)
00027         {
00028             node.getAnd().apply(this);
00029         }
00030         if(node.getInclusiveOrExp() != null)
00031         {
00032             node.getInclusiveOrExp().apply(this);
00033         }
00034         outAAndAndExp(node);
00035     }
00036     public void caseAAndBinOp(AAndBinOp node)
00037     {
00038         inAAndBinOp(node);
00039         if(node.getAnd() != null)
00040         {
00041             node.getAnd().apply(this);
00042         }
00043         outAAndBinOp(node);
00044     }
00045     public void caseAAndBitAndExp(AAndBitAndExp node)
00046     {
00047         inAAndBitAndExp(node);
00048         if(node.getBitAndExp() != null)
00049         {
00050             node.getBitAndExp().apply(this);
00051         }
00052         if(node.getBitAnd() != null)
00053         {
00054             node.getBitAnd().apply(this);
00055         }
00056         if(node.getEqExp() != null)
00057         {
00058             node.getEqExp().apply(this);
00059         }
00060         outAAndBitAndExp(node);
00061     }
00062     public void caseAAndExclusiveOrExp(AAndExclusiveOrExp node)
00063     {
00064         inAAndExclusiveOrExp(node);
00065         if(node.getBitAndExp() != null)
00066         {
00067             node.getBitAndExp().apply(this);
00068         }
00069         outAAndExclusiveOrExp(node);
00070     }
00071     public void caseAAndOrExp(AAndOrExp node)
00072     {
00073         inAAndOrExp(node);
00074         if(node.getAndExp() != null)
00075         {
00076             node.getAndExp().apply(this);
00077         }
00078         outAAndOrExp(node);
00079     }
00080     public void caseAArrayAccessPrimaryExp(AArrayAccessPrimaryExp node)
00081     {
00082         inAArrayAccessPrimaryExp(node);
00083         if(node.getArrayAccess() != null)
00084         {
00085             node.getArrayAccess().apply(this);
00086         }
00087         outAArrayAccessPrimaryExp(node);
00088     }
00089     public void caseABinaryExp(ABinaryExp node)
00090     {
00091         inABinaryExp(node);
00092         if(node.getLeft() != null)
00093         {
00094             node.getLeft().apply(this);
00095         }
00096         if(node.getBinOp() != null)
00097         {
00098             node.getBinOp().apply(this);
00099         }
00100         if(node.getRight() != null)
00101         {
00102             node.getRight().apply(this);
00103         }
00104         outABinaryExp(node);
00105     }
00106     public void caseABitAndBinOp(ABitAndBinOp node)
00107     {
00108         inABitAndBinOp(node);
00109         if(node.getBitAnd() != null)
00110         {
00111             node.getBitAnd().apply(this);
00112         }
00113         outABitAndBinOp(node);
00114     }
00115     public void caseABitComplementExp(ABitComplementExp node)
00116     {
00117         inABitComplementExp(node);
00118         if(node.getBitComplement() != null)
00119         {
00120             node.getBitComplement().apply(this);
00121         }
00122         if(node.getExp() != null)
00123         {
00124             node.getExp().apply(this);
00125         }
00126         outABitComplementExp(node);
00127     }
00128     public void caseABitComplementUnaryNotPlusMinusExp(ABitComplementUnaryNotPlusMinusExp node)
00129     {
00130         inABitComplementUnaryNotPlusMinusExp(node);
00131         if(node.getBitComplement() != null)
00132         {
00133             node.getBitComplement().apply(this);
00134         }
00135         if(node.getUnaryExp() != null)
00136         {
00137             node.getUnaryExp().apply(this);
00138         }
00139         outABitComplementUnaryNotPlusMinusExp(node);
00140     }
00141     public void caseABitOrBinOp(ABitOrBinOp node)
00142     {
00143         inABitOrBinOp(node);
00144         if(node.getBitOr() != null)
00145         {
00146             node.getBitOr().apply(this);
00147         }
00148         outABitOrBinOp(node);
00149     }
00150     public void caseABitXorBinOp(ABitXorBinOp node)
00151     {
00152         inABitXorBinOp(node);
00153         if(node.getBitXor() != null)
00154         {
00155             node.getBitXor().apply(this);
00156         }
00157         outABitXorBinOp(node);
00158     }
00159     public void caseABooleanPrimitiveType(ABooleanPrimitiveType node)
00160     {
00161         inABooleanPrimitiveType(node);
00162         if(node.getBoolean() != null)
00163         {
00164             node.getBoolean().apply(this);
00165         }
00166         outABooleanPrimitiveType(node);
00167     }
00168     public void caseABytePrimitiveType(ABytePrimitiveType node)
00169     {
00170         inABytePrimitiveType(node);
00171         if(node.getByte() != null)
00172         {
00173             node.getByte().apply(this);
00174         }
00175         outABytePrimitiveType(node);
00176     }
00177     public void caseACastUnaryNotPlusMinusExp(ACastUnaryNotPlusMinusExp node)
00178     {
00179         inACastUnaryNotPlusMinusExp(node);
00180         if(node.getCastExp() != null)
00181         {
00182             node.getCastExp().apply(this);
00183         }
00184         outACastUnaryNotPlusMinusExp(node);
00185     }
00186     public void caseACharLiteral(ACharLiteral node)
00187     {
00188         inACharLiteral(node);
00189         if(node.getCharLiteral() != null)
00190         {
00191             node.getCharLiteral().apply(this);
00192         }
00193         outACharLiteral(node);
00194     }
00195     public void caseACharPrimitiveType(ACharPrimitiveType node)
00196     {
00197         inACharPrimitiveType(node);
00198         if(node.getChar() != null)
00199         {
00200             node.getChar().apply(this);
00201         }
00202         outACharPrimitiveType(node);
00203     }
00204     public void caseAColonExp(AColonExp node)
00205     {
00206         inAColonExp(node);
00207         if(node.getColon() != null)
00208         {
00209             node.getColon().apply(this);
00210         }
00211         if(node.getExp() != null)
00212         {
00213             node.getExp().apply(this);
00214         }
00215         outAColonExp(node);
00216     }
00217     public void caseAComplementExp(AComplementExp node)
00218     {
00219         inAComplementExp(node);
00220         if(node.getNot() != null)
00221         {
00222             node.getNot().apply(this);
00223         }
00224         if(node.getExp() != null)
00225         {
00226             node.getExp().apply(this);
00227         }
00228         outAComplementExp(node);
00229     }
00230     public void caseAComplementUnaryNotPlusMinusExp(AComplementUnaryNotPlusMinusExp node)
00231     {
00232         inAComplementUnaryNotPlusMinusExp(node);
00233         if(node.getNot() != null)
00234         {
00235             node.getNot().apply(this);
00236         }
00237         if(node.getUnaryExp() != null)
00238         {
00239             node.getUnaryExp().apply(this);
00240         }
00241         outAComplementUnaryNotPlusMinusExp(node);
00242     }
00243     public void caseAConditionalExp(AConditionalExp node)
00244     {
00245         inAConditionalExp(node);
00246         if(node.getConditionalExp() != null)
00247         {
00248             node.getConditionalExp().apply(this);
00249         }
00250         outAConditionalExp(node);
00251     }
00252     public void caseACpl(ACpl node)
00253     {
00254         inACpl(node);
00255         if(node.getComma() != null)
00256         {
00257             node.getComma().apply(this);
00258         }
00259         if(node.getParamList() != null)
00260         {
00261             node.getParamList().apply(this);
00262         }
00263         outACpl(node);
00264     }
00265     public void caseADecIntLiteral(ADecIntLiteral node)
00266     {
00267         inADecIntLiteral(node);
00268         if(node.getDecIntLiteral() != null)
00269         {
00270             node.getDecIntLiteral().apply(this);
00271         }
00272         outADecIntLiteral(node);
00273     }
00274     public void caseADecLongLiteral(ADecLongLiteral node)
00275     {
00276         inADecLongLiteral(node);
00277         if(node.getDecLongLiteral() != null)
00278         {
00279             node.getDecLongLiteral().apply(this);
00280         }
00281         outADecLongLiteral(node);
00282     }
00283     public void caseADoubleLiteral(ADoubleLiteral node)
00284     {
00285         inADoubleLiteral(node);
00286         if(node.getDoubleLiteral() != null)
00287         {
00288             node.getDoubleLiteral().apply(this);
00289         }
00290         outADoubleLiteral(node);
00291     }
00292     public void caseADoublePrimitiveType(ADoublePrimitiveType node)
00293     {
00294         inADoublePrimitiveType(node);
00295         if(node.getDouble() != null)
00296         {
00297             node.getDouble().apply(this);
00298         }
00299         outADoublePrimitiveType(node);
00300     }
00301     public void caseAEndOfLineComment(AEndOfLineComment node)
00302     {
00303         inAEndOfLineComment(node);
00304         if(node.getEndOfLineComment() != null)
00305         {
00306             node.getEndOfLineComment().apply(this);
00307         }
00308         outAEndOfLineComment(node);
00309     }
00310     public void caseAEqBitAndExp(AEqBitAndExp node)
00311     {
00312         inAEqBitAndExp(node);
00313         if(node.getEqExp() != null)
00314         {
00315             node.getEqExp().apply(this);
00316         }
00317         outAEqBitAndExp(node);
00318     }
00319     public void caseAEqEqExp(AEqEqExp node)
00320     {
00321         inAEqEqExp(node);
00322         if(node.getEqExp() != null)
00323         {
00324             node.getEqExp().apply(this);
00325         }
00326         if(node.getEqual() != null)
00327         {
00328             node.getEqual().apply(this);
00329         }
00330         if(node.getRelExp() != null)
00331         {
00332             node.getRelExp().apply(this);
00333         }
00334         outAEqEqExp(node);
00335     }
00336     public void caseAEqualBinOp(AEqualBinOp node)
00337     {
00338         inAEqualBinOp(node);
00339         if(node.getEqual() != null)
00340         {
00341             node.getEqual().apply(this);
00342         }
00343         outAEqualBinOp(node);
00344     }
00345     public void caseAExpressionPropositionDefinition(AExpressionPropositionDefinition node)
00346     {
00347         inAExpressionPropositionDefinition(node);
00348         if(node.getExpression() != null)
00349         {
00350             node.getExpression().apply(this);
00351         }
00352         if(node.getId() != null)
00353         {
00354             node.getId().apply(this);
00355         }
00356         if(node.getLParen() != null)
00357         {
00358             node.getLParen().apply(this);
00359         }
00360         if(node.getParams() != null)
00361         {
00362             node.getParams().apply(this);
00363         }
00364         if(node.getRParen() != null)
00365         {
00366             node.getRParen().apply(this);
00367         }
00368         if(node.getColonExp() != null)
00369         {
00370             node.getColonExp().apply(this);
00371         }
00372         if(node.getSemicolon() != null)
00373         {
00374             node.getSemicolon().apply(this);
00375         }
00376         {
00377             Object temp[] = node.getComment().toArray();
00378             for(int i = 0; i < temp.length; i++)
00379             {
00380                 ((PComment) temp[i]).apply(this);
00381             }
00382         }
00383         outAExpressionPropositionDefinition(node);
00384     }
00385     public void caseAFalseLiteral(AFalseLiteral node)
00386     {
00387         inAFalseLiteral(node);
00388         if(node.getFalse() != null)
00389         {
00390             node.getFalse().apply(this);
00391         }
00392         outAFalseLiteral(node);
00393     }
00394     public void caseAFieldAccessPrimaryExp(AFieldAccessPrimaryExp node)
00395     {
00396         inAFieldAccessPrimaryExp(node);
00397         if(node.getFieldAccess() != null)
00398         {
00399             node.getFieldAccess().apply(this);
00400         }
00401         outAFieldAccessPrimaryExp(node);
00402     }
00403     public void caseAFloatLiteral(AFloatLiteral node)
00404     {
00405         inAFloatLiteral(node);
00406         if(node.getFloatLiteral() != null)
00407         {
00408             node.getFloatLiteral().apply(this);
00409         }
00410         outAFloatLiteral(node);
00411     }
00412     public void caseAFloatPrimitiveType(AFloatPrimitiveType node)
00413     {
00414         inAFloatPrimitiveType(node);
00415         if(node.getFloat() != null)
00416         {
00417             node.getFloat().apply(this);
00418         }
00419         outAFloatPrimitiveType(node);
00420     }
00421     public void caseAGreaterBinOp(AGreaterBinOp node)
00422     {
00423         inAGreaterBinOp(node);
00424         if(node.getGreater() != null)
00425         {
00426             node.getGreater().apply(this);
00427         }
00428         outAGreaterBinOp(node);
00429     }
00430     public void caseAGreaterEqualBinOp(AGreaterEqualBinOp node)
00431     {
00432         inAGreaterEqualBinOp(node);
00433         if(node.getGreaterEqual() != null)
00434         {
00435             node.getGreaterEqual().apply(this);
00436         }
00437         outAGreaterEqualBinOp(node);
00438     }
00439     public void caseAGreaterEqualRelExp(AGreaterEqualRelExp node)
00440     {
00441         inAGreaterEqualRelExp(node);
00442         if(node.getRelExp() != null)
00443         {
00444             node.getRelExp().apply(this);
00445         }
00446         if(node.getGreaterEqual() != null)
00447         {
00448             node.getGreaterEqual().apply(this);
00449         }
00450         if(node.getShiftExp() != null)
00451         {
00452             node.getShiftExp().apply(this);
00453         }
00454         outAGreaterEqualRelExp(node);
00455     }
00456     public void caseAGreaterRelExp(AGreaterRelExp node)
00457     {
00458         inAGreaterRelExp(node);
00459         if(node.getRelExp() != null)
00460         {
00461             node.getRelExp().apply(this);
00462         }
00463         if(node.getGreater() != null)
00464         {
00465             node.getGreater().apply(this);
00466         }
00467         if(node.getShiftExp() != null)
00468         {
00469             node.getShiftExp().apply(this);
00470         }
00471         outAGreaterRelExp(node);
00472     }
00473     public void caseAHexIntLiteral(AHexIntLiteral node)
00474     {
00475         inAHexIntLiteral(node);
00476         if(node.getHexIntLiteral() != null)
00477         {
00478             node.getHexIntLiteral().apply(this);
00479         }
00480         outAHexIntLiteral(node);
00481     }
00482     public void caseAHexLongLiteral(AHexLongLiteral node)
00483     {
00484         inAHexLongLiteral(node);
00485         if(node.getHexLongLiteral() != null)
00486         {
00487             node.getHexLongLiteral().apply(this);
00488         }
00489         outAHexLongLiteral(node);
00490     }
00491     public void caseAInclusiveOrAndExp(AInclusiveOrAndExp node)
00492     {
00493         inAInclusiveOrAndExp(node);
00494         if(node.getInclusiveOrExp() != null)
00495         {
00496             node.getInclusiveOrExp().apply(this);
00497         }
00498         outAInclusiveOrAndExp(node);
00499     }
00500     public void caseAInstanceofExp(AInstanceofExp node)
00501     {
00502         inAInstanceofExp(node);
00503         if(node.getExp() != null)
00504         {
00505             node.getExp().apply(this);
00506         }
00507         if(node.getInstanceof() != null)
00508         {
00509             node.getInstanceof().apply(this);
00510         }
00511         if(node.getType() != null)
00512         {
00513             node.getType().apply(this);
00514         }
00515         outAInstanceofExp(node);
00516     }
00517     public void caseAInstanceofRelExp(AInstanceofRelExp node)
00518     {
00519         inAInstanceofRelExp(node);
00520         if(node.getRelExp() != null)
00521         {
00522             node.getRelExp().apply(this);
00523         }
00524         if(node.getInstanceof() != null)
00525         {
00526             node.getInstanceof().apply(this);
00527         }
00528         if(node.getType() != null)
00529         {
00530             node.getType().apply(this);
00531         }
00532         outAInstanceofRelExp(node);
00533     }
00534     public void caseAInstanceParams(AInstanceParams node)
00535     {
00536         inAInstanceParams(node);
00537         if(node.getThis() != null)
00538         {
00539             node.getThis().apply(this);
00540         }
00541         if(node.getCpl() != null)
00542         {
00543             node.getCpl().apply(this);
00544         }
00545         outAInstanceParams(node);
00546     }
00547     public void caseAIntPrimitiveType(AIntPrimitiveType node)
00548     {
00549         inAIntPrimitiveType(node);
00550         if(node.getInt() != null)
00551         {
00552             node.getInt().apply(this);
00553         }
00554         outAIntPrimitiveType(node);
00555     }
00556     public void caseAInvokePropositionDefinition(AInvokePropositionDefinition node)
00557     {
00558         inAInvokePropositionDefinition(node);
00559         if(node.getInvoke() != null)
00560         {
00561             node.getInvoke().apply(this);
00562         }
00563         if(node.getId() != null)
00564         {
00565             node.getId().apply(this);
00566         }
00567         if(node.getLParen() != null)
00568         {
00569             node.getLParen().apply(this);
00570         }
00571         if(node.getParams() != null)
00572         {
00573             node.getParams().apply(this);
00574         }
00575         if(node.getRParen() != null)
00576         {
00577             node.getRParen().apply(this);
00578         }
00579         if(node.getColonExp() != null)
00580         {
00581             node.getColonExp().apply(this);
00582         }
00583         if(node.getSemicolon() != null)
00584         {
00585             node.getSemicolon().apply(this);
00586         }
00587         {
00588             Object temp[] = node.getComment().toArray();
00589             for(int i = 0; i < temp.length; i++)
00590             {
00591                 ((PComment) temp[i]).apply(this);
00592             }
00593         }
00594         outAInvokePropositionDefinition(node);
00595     }
00596     public void caseALeftShiftExp(ALeftShiftExp node)
00597     {
00598         inALeftShiftExp(node);
00599         if(node.getShiftExp() != null)
00600         {
00601             node.getShiftExp().apply(this);
00602         }
00603         if(node.getShiftLeft() != null)
00604         {
00605             node.getShiftLeft().apply(this);
00606         }
00607         if(node.getAddExp() != null)
00608         {
00609             node.getAddExp().apply(this);
00610         }
00611         outALeftShiftExp(node);
00612     }
00613     public void caseALessBinOp(ALessBinOp node)
00614     {
00615         inALessBinOp(node);
00616         if(node.getLess() != null)
00617         {
00618             node.getLess().apply(this);
00619         }
00620         outALessBinOp(node);
00621     }
00622     public void caseALessEqualBinOp(ALessEqualBinOp node)
00623     {
00624         inALessEqualBinOp(node);
00625         if(node.getLessEqual() != null)
00626         {
00627             node.getLessEqual().apply(this);
00628         }
00629         outALessEqualBinOp(node);
00630     }
00631     public void caseALessEqualRelExp(ALessEqualRelExp node)
00632     {
00633         inALessEqualRelExp(node);
00634         if(node.getRelExp() != null)
00635         {
00636             node.getRelExp().apply(this);
00637         }
00638         if(node.getLessEqual() != null)
00639         {
00640             node.getLessEqual().apply(this);
00641         }
00642         if(node.getShiftExp() != null)
00643         {
00644             node.getShiftExp().apply(this);
00645         }
00646         outALessEqualRelExp(node);
00647     }
00648     public void caseALessRelExp(ALessRelExp node)
00649     {
00650         inALessRelExp(node);
00651         if(node.getRelExp() != null)
00652         {
00653             node.getRelExp().apply(this);
00654         }
00655         if(node.getLess() != null)
00656         {
00657             node.getLess().apply(this);
00658         }
00659         if(node.getShiftExp() != null)
00660         {
00661             node.getShiftExp().apply(this);
00662         }
00663         outALessRelExp(node);
00664     }
00665     public void caseALiteralExp(ALiteralExp node)
00666     {
00667         inALiteralExp(node);
00668         if(node.getLiteral() != null)
00669         {
00670             node.getLiteral().apply(this);
00671         }
00672         outALiteralExp(node);
00673     }
00674     public void caseALiteralPrimaryExp(ALiteralPrimaryExp node)
00675     {
00676         inALiteralPrimaryExp(node);
00677         if(node.getLiteral() != null)
00678         {
00679             node.getLiteral().apply(this);
00680         }
00681         outALiteralPrimaryExp(node);
00682     }
00683     public void caseALocationPropositionDefinition(ALocationPropositionDefinition node)
00684     {
00685         inALocationPropositionDefinition(node);
00686         if(node.getLocation() != null)
00687         {
00688             node.getLocation().apply(this);
00689         }
00690         if(node.getLBracket() != null)
00691         {
00692             node.getLBracket().apply(this);
00693         }
00694         if(node.getLabel() != null)
00695         {
00696             node.getLabel().apply(this);
00697         }
00698         if(node.getRBracket() != null)
00699         {
00700             node.getRBracket().apply(this);
00701         }
00702         if(node.getId() != null)
00703         {
00704             node.getId().apply(this);
00705         }
00706         if(node.getLParen() != null)
00707         {
00708             node.getLParen().apply(this);
00709         }
00710         if(node.getParams() != null)
00711         {
00712             node.getParams().apply(this);
00713         }
00714         if(node.getRParen() != null)
00715         {
00716             node.getRParen().apply(this);
00717         }
00718         if(node.getColonExp() != null)
00719         {
00720             node.getColonExp().apply(this);
00721         }
00722         if(node.getSemicolon() != null)
00723         {
00724             node.getSemicolon().apply(this);
00725         }
00726         {
00727             Object temp[] = node.getComment().toArray();
00728             for(int i = 0; i < temp.length; i++)
00729             {
00730                 ((PComment) temp[i]).apply(this);
00731             }
00732         }
00733         outALocationPropositionDefinition(node);
00734     }
00735     public void caseALongPrimitiveType(ALongPrimitiveType node)
00736     {
00737         inALongPrimitiveType(node);
00738         if(node.getLong() != null)
00739         {
00740             node.getLong().apply(this);
00741         }
00742         outALongPrimitiveType(node);
00743     }
00744     public void caseAMinusAddExp(AMinusAddExp node)
00745     {
00746         inAMinusAddExp(node);
00747         if(node.getAddExp() != null)
00748         {
00749             node.getAddExp().apply(this);
00750         }
00751         if(node.getMinus() != null)
00752         {
00753             node.getMinus().apply(this);
00754         }
00755         if(node.getMultExp() != null)
00756         {
00757             node.getMultExp().apply(this);
00758         }
00759         outAMinusAddExp(node);
00760     }
00761     public void caseAMinusBinOp(AMinusBinOp node)
00762     {
00763         inAMinusBinOp(node);
00764         if(node.getMinus() != null)
00765         {
00766             node.getMinus().apply(this);
00767         }
00768         outAMinusBinOp(node);
00769     }
00770     public void caseAMinusUnaryExp(AMinusUnaryExp node)
00771     {
00772         inAMinusUnaryExp(node);
00773         if(node.getMinus() != null)
00774         {
00775             node.getMinus().apply(this);
00776         }
00777         if(node.getUnaryExp() != null)
00778         {
00779             node.getUnaryExp().apply(this);
00780         }
00781         outAMinusUnaryExp(node);
00782     }
00783     public void caseAMultAddExp(AMultAddExp node)
00784     {
00785         inAMultAddExp(node);
00786         if(node.getMultExp() != null)
00787         {
00788             node.getMultExp().apply(this);
00789         }
00790         outAMultAddExp(node);
00791     }
00792     public void caseANameExp(ANameExp node)
00793     {
00794         inANameExp(node);
00795         if(node.getName() != null)
00796         {
00797             node.getName().apply(this);
00798         }
00799         outANameExp(node);
00800     }
00801     public void caseANamePostfixExp(ANamePostfixExp node)
00802     {
00803         inANamePostfixExp(node);
00804         if(node.getName() != null)
00805         {
00806             node.getName().apply(this);
00807         }
00808         outANamePostfixExp(node);
00809     }
00810     public void caseANavigationExp(ANavigationExp node)
00811     {
00812         inANavigationExp(node);
00813         if(node.getExp() != null)
00814         {
00815             node.getExp().apply(this);
00816         }
00817         if(node.getNavigation() != null)
00818         {
00819             node.getNavigation().apply(this);
00820         }
00821         outANavigationExp(node);
00822     }
00823     public void caseANegativeExp(ANegativeExp node)
00824     {
00825         inANegativeExp(node);
00826         if(node.getMinus() != null)
00827         {
00828             node.getMinus().apply(this);
00829         }
00830         if(node.getExp() != null)
00831         {
00832             node.getExp().apply(this);
00833         }
00834         outANegativeExp(node);
00835     }
00836     public void caseANeqEqExp(ANeqEqExp node)
00837     {
00838         inANeqEqExp(node);
00839         if(node.getEqExp() != null)
00840         {
00841             node.getEqExp().apply(this);
00842         }
00843         if(node.getNotEqual() != null)
00844         {
00845             node.getNotEqual().apply(this);
00846         }
00847         if(node.getRelExp() != null)
00848         {
00849             node.getRelExp().apply(this);
00850         }
00851         outANeqEqExp(node);
00852     }
00853     public void caseANotEqualBinOp(ANotEqualBinOp node)
00854     {
00855         inANotEqualBinOp(node);
00856         if(node.getNotEqual() != null)
00857         {
00858             node.getNotEqual().apply(this);
00859         }
00860         outANotEqualBinOp(node);
00861     }
00862     public void caseANullLiteral(ANullLiteral node)
00863     {
00864         inANullLiteral(node);
00865         if(node.getNull() != null)
00866         {
00867             node.getNull().apply(this);
00868         }
00869         outANullLiteral(node);
00870     }
00871     public void caseAOctIntLiteral(AOctIntLiteral node)
00872     {
00873         inAOctIntLiteral(node);
00874         if(node.getOctIntLiteral() != null)
00875         {
00876             node.getOctIntLiteral().apply(this);
00877         }
00878         outAOctIntLiteral(node);
00879     }
00880     public void caseAOctLongLiteral(AOctLongLiteral node)
00881     {
00882         inAOctLongLiteral(node);
00883         if(node.getOctLongLiteral() != null)
00884         {
00885             node.getOctLongLiteral().apply(this);
00886         }
00887         outAOctLongLiteral(node);
00888     }
00889     public void caseAOrBinOp(AOrBinOp node)
00890     {
00891         inAOrBinOp(node);
00892         if(node.getOr() != null)
00893         {
00894             node.getOr().apply(this);
00895         }
00896         outAOrBinOp(node);
00897     }
00898     public void caseAOrConditionalExp(AOrConditionalExp node)
00899     {
00900         inAOrConditionalExp(node);
00901         if(node.getOrExp() != null)
00902         {
00903             node.getOrExp().apply(this);
00904         }
00905         outAOrConditionalExp(node);
00906     }
00907     public void caseAOrInclusiveOrExp(AOrInclusiveOrExp node)
00908     {
00909         inAOrInclusiveOrExp(node);
00910         if(node.getInclusiveOrExp() != null)
00911         {
00912             node.getInclusiveOrExp().apply(this);
00913         }
00914         if(node.getBitOr() != null)
00915         {
00916             node.getBitOr().apply(this);
00917         }
00918         if(node.getExclusiveOrExp() != null)
00919         {
00920             node.getExclusiveOrExp().apply(this);
00921         }
00922         outAOrInclusiveOrExp(node);
00923     }
00924     public void caseAOrOrExp(AOrOrExp node)
00925     {
00926         inAOrOrExp(node);
00927         if(node.getOrExp() != null)
00928         {
00929             node.getOrExp().apply(this);
00930         }
00931         if(node.getOr() != null)
00932         {
00933             node.getOr().apply(this);
00934         }
00935         if(node.getAndExp() != null)
00936         {
00937             node.getAndExp().apply(this);
00938         }
00939         outAOrOrExp(node);
00940     }
00941     public void caseAParamParamList(AParamParamList node)
00942     {
00943         inAParamParamList(node);
00944         if(node.getName() != null)
00945         {
00946             node.getName().apply(this);
00947         }
00948         {
00949             Object temp[] = node.getDim().toArray();
00950             for(int i = 0; i < temp.length; i++)
00951             {
00952                 ((TDim) temp[i]).apply(this);
00953             }
00954         }
00955         if(node.getId() != null)
00956         {
00957             node.getId().apply(this);
00958         }
00959         outAParamParamList(node);
00960     }
00961     public void caseAParamsParamList(AParamsParamList node)
00962     {
00963         inAParamsParamList(node);
00964         if(node.getParamList() != null)
00965         {
00966             node.getParamList().apply(this);
00967         }
00968         if(node.getComma() != null)
00969         {
00970             node.getComma().apply(this);
00971         }
00972         if(node.getName() != null)
00973         {
00974             node.getName().apply(this);
00975         }
00976         {
00977             Object temp[] = node.getDim().toArray();
00978             for(int i = 0; i < temp.length; i++)
00979             {
00980                 ((TDim) temp[i]).apply(this);
00981             }
00982         }
00983         if(node.getId() != null)
00984         {
00985             node.getId().apply(this);
00986         }
00987         outAParamsParamList(node);
00988     }
00989     public void caseAParenExp(AParenExp node)
00990     {
00991         inAParenExp(node);
00992         if(node.getLParen() != null)
00993         {
00994             node.getLParen().apply(this);
00995         }
00996         if(node.getExp() != null)
00997         {
00998             node.getExp().apply(this);
00999         }
01000         if(node.getRParen() != null)
01001         {
01002             node.getRParen().apply(this);
01003         }
01004         outAParenExp(node);
01005     }
01006     public void caseAParenPrimaryExp(AParenPrimaryExp node)
01007     {
01008         inAParenPrimaryExp(node);
01009         if(node.getLParen() != null)
01010         {
01011             node.getLParen().apply(this);
01012         }
01013         if(node.getExp() != null)
01014         {
01015             node.getExp().apply(this);
01016         }
01017         if(node.getRParen() != null)
01018         {
01019             node.getRParen().apply(this);
01020         }
01021         outAParenPrimaryExp(node);
01022     }
01023     public void caseAPlusAddExp(APlusAddExp node)
01024     {
01025         inAPlusAddExp(node);
01026         if(node.getAddExp() != null)
01027         {
01028             node.getAddExp().apply(this);
01029         }
01030         if(node.getPlus() != null)
01031         {
01032             node.getPlus().apply(this);
01033         }
01034         if(node.getMultExp() != null)
01035         {
01036             node.getMultExp().apply(this);
01037         }
01038         outAPlusAddExp(node);
01039     }
01040     public void caseAPlusBinOp(APlusBinOp node)
01041     {
01042         inAPlusBinOp(node);
01043         if(node.getPlus() != null)
01044         {
01045             node.getPlus().apply(this);
01046         }
01047         outAPlusBinOp(node);
01048     }
01049     public void caseAPlusUnaryExp(APlusUnaryExp node)
01050     {
01051         inAPlusUnaryExp(node);
01052         if(node.getPlus() != null)
01053         {
01054             node.getPlus().apply(this);
01055         }
01056         if(node.getUnaryExp() != null)
01057         {
01058             node.getUnaryExp().apply(this);
01059         }
01060         outAPlusUnaryExp(node);
01061     }
01062     public void caseAPostfixUnaryNotPlusMinusExp(APostfixUnaryNotPlusMinusExp node)
01063     {
01064         inAPostfixUnaryNotPlusMinusExp(node);
01065         if(node.getPostfixExp() != null)
01066         {
01067             node.getPostfixExp().apply(this);
01068         }
01069         outAPostfixUnaryNotPlusMinusExp(node);
01070     }
01071     public void caseAPrimaryPostfixExp(APrimaryPostfixExp node)
01072     {
01073         inAPrimaryPostfixExp(node);
01074         if(node.getPrimaryExp() != null)
01075         {
01076             node.getPrimaryExp().apply(this);
01077         }
01078         outAPrimaryPostfixExp(node);
01079     }
01080     public void caseAQualifiedName(AQualifiedName node)
01081     {
01082         inAQualifiedName(node);
01083         if(node.getName() != null)
01084         {
01085             node.getName().apply(this);
01086         }
01087         if(node.getDot() != null)
01088         {
01089             node.getDot().apply(this);
01090         }
01091         if(node.getId() != null)
01092         {
01093             node.getId().apply(this);
01094         }
01095         outAQualifiedName(node);
01096     }
01097     public void caseAQuestionConditionalExp(AQuestionConditionalExp node)
01098     {
01099         inAQuestionConditionalExp(node);
01100         if(node.getOrExp() != null)
01101         {
01102             node.getOrExp().apply(this);
01103         }
01104         if(node.getQuestion() != null)
01105         {
01106             node.getQuestion().apply(this);
01107         }
01108         if(node.getTrueExp() != null)
01109         {
01110             node.getTrueExp().apply(this);
01111         }
01112         if(node.getColon() != null)
01113         {
01114             node.getColon().apply(this);
01115         }
01116         if(node.getFalseExp() != null)
01117         {
01118             node.getFalseExp().apply(this);
01119         }
01120         outAQuestionConditionalExp(node);
01121     }
01122     public void caseAQuestionExp(AQuestionExp node)
01123     {
01124         inAQuestionExp(node);
01125         if(node.getExp() != null)
01126         {
01127             node.getExp().apply(this);
01128         }
01129         if(node.getQuestion() != null)
01130         {
01131             node.getQuestion().apply(this);
01132         }
01133         if(node.getTrueExp() != null)
01134         {
01135             node.getTrueExp().apply(this);
01136         }
01137         if(node.getColon() != null)
01138         {
01139             node.getColon().apply(this);
01140         }
01141         if(node.getFalseExp() != null)
01142         {
01143             node.getFalseExp().apply(this);
01144         }
01145         outAQuestionExp(node);
01146     }
01147     public void caseARelEqExp(ARelEqExp node)
01148     {
01149         inARelEqExp(node);
01150         if(node.getRelExp() != null)
01151         {
01152             node.getRelExp().apply(this);
01153         }
01154         outARelEqExp(node);
01155     }
01156     public void caseAReturnPropositionDefinition(AReturnPropositionDefinition node)
01157     {
01158         inAReturnPropositionDefinition(node);
01159         if(node.getReturn() != null)
01160         {
01161             node.getReturn().apply(this);
01162         }
01163         if(node.getId() != null)
01164         {
01165             node.getId().apply(this);
01166         }
01167         if(node.getLParen() != null)
01168         {
01169             node.getLParen().apply(this);
01170         }
01171         if(node.getParams() != null)
01172         {
01173             node.getParams().apply(this);
01174         }
01175         if(node.getRParen() != null)
01176         {
01177             node.getRParen().apply(this);
01178         }
01179         if(node.getColonExp() != null)
01180         {
01181             node.getColonExp().apply(this);
01182         }
01183         if(node.getSemicolon() != null)
01184         {
01185             node.getSemicolon().apply(this);
01186         }
01187         {
01188             Object temp[] = node.getComment().toArray();
01189             for(int i = 0; i < temp.length; i++)
01190             {
01191                 ((PComment) temp[i]).apply(this);
01192             }
01193         }
01194         outAReturnPropositionDefinition(node);
01195     }
01196     public void caseAReturnValueExp(AReturnValueExp node)
01197     {
01198         inAReturnValueExp(node);
01199         if(node.getRetVal() != null)
01200         {
01201             node.getRetVal().apply(this);
01202         }
01203         outAReturnValueExp(node);
01204     }
01205     public void caseAReturnValuePrimaryExp(AReturnValuePrimaryExp node)
01206     {
01207         inAReturnValuePrimaryExp(node);
01208         if(node.getRetVal() != null)
01209         {
01210             node.getRetVal().apply(this);
01211         }
01212         outAReturnValuePrimaryExp(node);
01213     }
01214     public void caseAShiftLeftBinOp(AShiftLeftBinOp node)
01215     {
01216         inAShiftLeftBinOp(node);
01217         if(node.getShiftLeft() != null)
01218         {
01219             node.getShiftLeft().apply(this);
01220         }
01221         outAShiftLeftBinOp(node);
01222     }
01223     public void caseAShiftRelExp(AShiftRelExp node)
01224     {
01225         inAShiftRelExp(node);
01226         if(node.getShiftExp() != null)
01227         {
01228             node.getShiftExp().apply(this);
01229         }
01230         outAShiftRelExp(node);
01231     }
01232     public void caseAShortPrimitiveType(AShortPrimitiveType node)
01233     {
01234         inAShortPrimitiveType(node);
01235         if(node.getShort() != null)
01236         {
01237             node.getShort().apply(this);
01238         }
01239         outAShortPrimitiveType(node);
01240     }
01241     public void caseASignedRightShiftExp(ASignedRightShiftExp node)
01242     {
01243         inASignedRightShiftExp(node);
01244         if(node.getShiftExp() != null)
01245         {
01246             node.getShiftExp().apply(this);
01247         }
01248         if(node.getSignedShiftRight() != null)
01249         {
01250             node.getSignedShiftRight().apply(this);
01251         }
01252         if(node.getAddExp() != null)
01253         {
01254             node.getAddExp().apply(this);
01255         }
01256         outASignedRightShiftExp(node);
01257     }
01258     public void caseASignedShiftRightBinOp(ASignedShiftRightBinOp node)
01259     {
01260         inASignedShiftRightBinOp(node);
01261         if(node.getSignedShiftRight() != null)
01262         {
01263             node.getSignedShiftRight().apply(this);
01264         }
01265         outASignedShiftRightBinOp(node);
01266     }
01267     public void caseASimpleName(ASimpleName node)
01268     {
01269         inASimpleName(node);
01270         if(node.getId() != null)
01271         {
01272             node.getId().apply(this);
01273         }
01274         outASimpleName(node);
01275     }
01276     public void caseAStaticParams(AStaticParams node)
01277     {
01278         inAStaticParams(node);
01279         if(node.getParamList() != null)
01280         {
01281             node.getParamList().apply(this);
01282         }
01283         outAStaticParams(node);
01284     }
01285     public void caseAStringLiteral(AStringLiteral node)
01286     {
01287         inAStringLiteral(node);
01288         if(node.getStringLiteral() != null)
01289         {
01290             node.getStringLiteral().apply(this);
01291         }
01292         outAStringLiteral(node);
01293     }
01294     public void caseAStrongArrayNavigation(AStrongArrayNavigation node)
01295     {
01296         inAStrongArrayNavigation(node);
01297         if(node.getLBracket() != null)
01298         {
01299             node.getLBracket().apply(this);
01300         }
01301         if(node.getExp() != null)
01302         {
01303             node.getExp().apply(this);
01304         }
01305         if(node.getRBracket() != null)
01306         {
01307             node.getRBracket().apply(this);
01308         }
01309         outAStrongArrayNavigation(node);
01310     }
01311     public void caseAStrongCastExp(AStrongCastExp node)
01312     {
01313         inAStrongCastExp(node);
01314         if(node.getLParen() != null)
01315         {
01316             node.getLParen().apply(this);
01317         }
01318         if(node.getType() != null)
01319         {
01320             node.getType().apply(this);
01321         }
01322         {
01323             Object temp[] = node.getDim().toArray();
01324             for(int i = 0; i < temp.length; i++)
01325             {
01326                 ((TDim) temp[i]).apply(this);
01327             }
01328         }
01329         if(node.getRParen() != null)
01330         {
01331             node.getRParen().apply(this);
01332         }
01333         if(node.getExp() != null)
01334         {
01335             node.getExp().apply(this);
01336         }
01337         outAStrongCastExp(node);
01338     }
01339     public void caseAStrongDivBinOp(AStrongDivBinOp node)
01340     {
01341         inAStrongDivBinOp(node);
01342         if(node.getStrongDiv() != null)
01343         {
01344             node.getStrongDiv().apply(this);
01345         }
01346         outAStrongDivBinOp(node);
01347     }
01348     public void caseAStrongDivMultExp(AStrongDivMultExp node)
01349     {
01350         inAStrongDivMultExp(node);
01351         if(node.getMultExp() != null)
01352         {
01353             node.getMultExp().apply(this);
01354         }
01355         if(node.getStrongDiv() != null)
01356         {
01357             node.getStrongDiv().apply(this);
01358         }
01359         if(node.getUnaryExp() != null)
01360         {
01361             node.getUnaryExp().apply(this);
01362         }
01363         outAStrongDivMultExp(node);
01364     }
01365     public void caseAStrongExpArrayAccess(AStrongExpArrayAccess node)
01366     {
01367         inAStrongExpArrayAccess(node);
01368         if(node.getPrimaryExp() != null)
01369         {
01370             node.getPrimaryExp().apply(this);
01371         }
01372         if(node.getLBracket() != null)
01373         {
01374             node.getLBracket().apply(this);
01375         }
01376         if(node.getExp() != null)
01377         {
01378             node.getExp().apply(this);
01379         }
01380         if(node.getRBracket() != null)
01381         {
01382             node.getRBracket().apply(this);
01383         }
01384         outAStrongExpArrayAccess(node);
01385     }
01386     public void caseAStrongExpCastExp(AStrongExpCastExp node)
01387     {
01388         inAStrongExpCastExp(node);
01389         if(node.getLParen() != null)
01390         {
01391             node.getLParen().apply(this);
01392         }
01393         if(node.getExp() != null)
01394         {
01395             node.getExp().apply(this);
01396         }
01397         if(node.getRParen() != null)
01398         {
01399             node.getRParen().apply(this);
01400         }
01401         if(node.getUnaryNotPlusMinusExp() != null)
01402         {
01403             node.getUnaryNotPlusMinusExp().apply(this);
01404         }
01405         outAStrongExpCastExp(node);
01406     }
01407     public void caseAStrongModBinOp(AStrongModBinOp node)
01408     {
01409         inAStrongModBinOp(node);
01410         if(node.getStrongMod() != null)
01411         {
01412             node.getStrongMod().apply(this);
01413         }
01414         outAStrongModBinOp(node);
01415     }
01416     public void caseAStrongModMultExp(AStrongModMultExp node)
01417     {
01418         inAStrongModMultExp(node);
01419         if(node.getMultExp() != null)
01420         {
01421             node.getMultExp().apply(this);
01422         }
01423         if(node.getStrongMod() != null)
01424         {
01425             node.getStrongMod().apply(this);
01426         }
01427         if(node.getUnaryExp() != null)
01428         {
01429             node.getUnaryExp().apply(this);
01430         }
01431         outAStrongModMultExp(node);
01432     }
01433     public void caseAStrongNameArrayAccess(AStrongNameArrayAccess node)
01434     {
01435         inAStrongNameArrayAccess(node);
01436         if(node.getName() != null)
01437         {
01438             node.getName().apply(this);
01439         }
01440         if(node.getLBracket() != null)
01441         {
01442             node.getLBracket().apply(this);
01443         }
01444         if(node.getExp() != null)
01445         {
01446             node.getExp().apply(this);
01447         }
01448         if(node.getRBracket() != null)
01449         {
01450             node.getRBracket().apply(this);
01451         }
01452         outAStrongNameArrayAccess(node);
01453     }
01454     public void caseAStrongNameCastExp(AStrongNameCastExp node)
01455     {
01456         inAStrongNameCastExp(node);
01457         if(node.getLParen() != null)
01458         {
01459             node.getLParen().apply(this);
01460         }
01461         if(node.getName() != null)
01462         {
01463             node.getName().apply(this);
01464         }
01465         {
01466             Object temp[] = node.getDim().toArray();
01467             for(int i = 0; i < temp.length; i++)
01468             {
01469                 ((TDim) temp[i]).apply(this);
01470             }
01471         }
01472         if(node.getRParen() != null)
01473         {
01474             node.getRParen().apply(this);
01475         }
01476         if(node.getUnaryExp() != null)
01477         {
01478             node.getUnaryExp().apply(this);
01479         }
01480         outAStrongNameCastExp(node);
01481     }
01482     public void caseAStrongObjectFieldAccess(AStrongObjectFieldAccess node)
01483     {
01484         inAStrongObjectFieldAccess(node);
01485         if(node.getPrimaryExp() != null)
01486         {
01487             node.getPrimaryExp().apply(this);
01488         }
01489         if(node.getDot() != null)
01490         {
01491             node.getDot().apply(this);
01492         }
01493         if(node.getId() != null)
01494         {
01495             node.getId().apply(this);
01496         }
01497         outAStrongObjectFieldAccess(node);
01498     }
01499     public void caseAStrongObjectNavigation(AStrongObjectNavigation node)
01500     {
01501         inAStrongObjectNavigation(node);
01502         if(node.getDot() != null)
01503         {
01504             node.getDot().apply(this);
01505         }
01506         if(node.getId() != null)
01507         {
01508             node.getId().apply(this);
01509         }
01510         outAStrongObjectNavigation(node);
01511     }
01512     public void caseAStrongPrimitiveCastExp(AStrongPrimitiveCastExp node)
01513     {
01514         inAStrongPrimitiveCastExp(node);
01515         if(node.getLParen() != null)
01516         {
01517             node.getLParen().apply(this);
01518         }
01519         if(node.getPrimitiveType() != null)
01520         {
01521             node.getPrimitiveType().apply(this);
01522         }
01523         {
01524             Object temp[] = node.getDim().toArray();
01525             for(int i = 0; i < temp.length; i++)
01526             {
01527                 ((TDim) temp[i]).apply(this);
01528             }
01529         }
01530         if(node.getRParen() != null)
01531         {
01532             node.getRParen().apply(this);
01533         }
01534         if(node.getUnaryExp() != null)
01535         {
01536             node.getUnaryExp().apply(this);
01537         }
01538         outAStrongPrimitiveCastExp(node);
01539     }
01540     public void caseAThisExp(AThisExp node)
01541     {
01542         inAThisExp(node);
01543         if(node.getThis() != null)
01544         {
01545             node.getThis().apply(this);
01546         }
01547         outAThisExp(node);
01548     }
01549     public void caseAThisPrimaryExp(AThisPrimaryExp node)
01550     {
01551         inAThisPrimaryExp(node);
01552         if(node.getThis() != null)
01553         {
01554             node.getThis().apply(this);
01555         }
01556         outAThisPrimaryExp(node);
01557     }
01558     public void caseATimesBinOp(ATimesBinOp node)
01559     {
01560         inATimesBinOp(node);
01561         if(node.getStar() != null)
01562         {
01563             node.getStar().apply(this);
01564         }
01565         outATimesBinOp(node);
01566     }
01567     public void caseATimesMultExp(ATimesMultExp node)
01568     {
01569         inATimesMultExp(node);
01570         if(node.getMultExp() != null)
01571         {
01572             node.getMultExp().apply(this);
01573         }
01574         if(node.getStar() != null)
01575         {
01576             node.getStar().apply(this);
01577         }
01578         if(node.getUnaryExp() != null)
01579         {
01580             node.getUnaryExp().apply(this);
01581         }
01582         outATimesMultExp(node);
01583     }
01584     public void caseATrueLiteral(ATrueLiteral node)
01585     {
01586         inATrueLiteral(node);
01587         if(node.getTrue() != null)
01588         {
01589             node.getTrue().apply(this);
01590         }
01591         outATrueLiteral(node);
01592     }
01593     public void caseAUnaryExpMultExp(AUnaryExpMultExp node)
01594     {
01595         inAUnaryExpMultExp(node);
01596         if(node.getUnaryExp() != null)
01597         {
01598             node.getUnaryExp().apply(this);
01599         }
01600         outAUnaryExpMultExp(node);
01601     }
01602     public void caseAUnaryNotPlusMinusUnaryExp(AUnaryNotPlusMinusUnaryExp node)
01603     {
01604         inAUnaryNotPlusMinusUnaryExp(node);
01605         if(node.getUnaryNotPlusMinusExp() != null)
01606         {
01607             node.getUnaryNotPlusMinusExp().apply(this);
01608         }
01609         outAUnaryNotPlusMinusUnaryExp(node);
01610     }
01611     public void caseAUnit(AUnit node)
01612     {
01613         inAUnit(node);
01614         if(node.getName() != null)
01615         {
01616             node.getName().apply(this);
01617         }
01618         {
01619             Object temp[] = node.getComment().toArray();
01620             for(int i = 0; i < temp.length; i++)
01621             {
01622                 ((PComment) temp[i]).apply(this);
01623             }
01624         }
01625         {
01626             Object temp[] = node.getPropositionDefinition().toArray();
01627             for(int i = 0; i < temp.length; i++)
01628             {
01629                 ((PPropositionDefinition) temp[i]).apply(this);
01630             }
01631         }
01632         outAUnit(node);
01633     }
01634     public void caseAUnsignedRightShiftExp(AUnsignedRightShiftExp node)
01635     {
01636         inAUnsignedRightShiftExp(node);
01637         if(node.getShiftExp() != null)
01638         {
01639             node.getShiftExp().apply(this);
01640         }
01641         if(node.getUnsignedShiftRight() != null)
01642         {
01643             node.getUnsignedShiftRight().apply(this);
01644         }
01645         if(node.getAddExp() != null)
01646         {
01647             node.getAddExp().apply(this);
01648         }
01649         outAUnsignedRightShiftExp(node);
01650     }
01651     public void caseAUnsignedShiftRightBinOp(AUnsignedShiftRightBinOp node)
01652     {
01653         inAUnsignedShiftRightBinOp(node);
01654         if(node.getUnsignedShiftRight() != null)
01655         {
01656             node.getUnsignedShiftRight().apply(this);
01657         }
01658         outAUnsignedShiftRightBinOp(node);
01659     }
01660     public void caseAXorExclusiveOrExp(AXorExclusiveOrExp node)
01661     {
01662         inAXorExclusiveOrExp(node);
01663         if(node.getExclusiveOrExp() != null)
01664         {
01665             node.getExclusiveOrExp().apply(this);
01666         }
01667         if(node.getBitXor() != null)
01668         {
01669             node.getBitXor().apply(this);
01670         }
01671         if(node.getBitAndExp() != null)
01672         {
01673             node.getBitAndExp().apply(this);
01674         }
01675         outAXorExclusiveOrExp(node);
01676     }
01677     public void caseAXorInclusiveOrExp(AXorInclusiveOrExp node)
01678     {
01679         inAXorInclusiveOrExp(node);
01680         if(node.getExclusiveOrExp() != null)
01681         {
01682             node.getExclusiveOrExp().apply(this);
01683         }
01684         outAXorInclusiveOrExp(node);
01685     }
01686     public void caseStart(Start node)
01687     {
01688         inStart(node);
01689         node.getPUnit().apply(this);
01690         node.getEOF().apply(this);
01691         outStart(node);
01692     }
01693     public void defaultIn(Node node)
01694     {
01695     }
01696     public void defaultOut(Node node)
01697     {
01698     }
01699     public void inAAddExpShiftExp(AAddExpShiftExp node)
01700     {
01701         defaultIn(node);
01702     }
01703     public void inAAndAndExp(AAndAndExp node)
01704     {
01705         defaultIn(node);
01706     }
01707     public void inAAndBinOp(AAndBinOp node)
01708     {
01709         defaultIn(node);
01710     }
01711     public void inAAndBitAndExp(AAndBitAndExp node)
01712     {
01713         defaultIn(node);
01714     }
01715     public void inAAndExclusiveOrExp(AAndExclusiveOrExp node)
01716     {
01717         defaultIn(node);
01718     }
01719     public void inAAndOrExp(AAndOrExp node)
01720     {
01721         defaultIn(node);
01722     }
01723     public void inAArrayAccessPrimaryExp(AArrayAccessPrimaryExp node)
01724     {
01725         defaultIn(node);
01726     }
01727     public void inABinaryExp(ABinaryExp node)
01728     {
01729         defaultIn(node);
01730     }
01731     public void inABitAndBinOp(ABitAndBinOp node)
01732     {
01733         defaultIn(node);
01734     }
01735     public void inABitComplementExp(ABitComplementExp node)
01736     {
01737         defaultIn(node);
01738     }
01739     public void inABitComplementUnaryNotPlusMinusExp(ABitComplementUnaryNotPlusMinusExp node)
01740     {
01741         defaultIn(node);
01742     }
01743     public void inABitOrBinOp(ABitOrBinOp node)
01744     {
01745         defaultIn(node);
01746     }
01747     public void inABitXorBinOp(ABitXorBinOp node)
01748     {
01749         defaultIn(node);
01750     }
01751     public void inABooleanPrimitiveType(ABooleanPrimitiveType node)
01752     {
01753         defaultIn(node);
01754     }
01755     public void inABytePrimitiveType(ABytePrimitiveType node)
01756     {
01757         defaultIn(node);
01758     }
01759     public void inACastUnaryNotPlusMinusExp(ACastUnaryNotPlusMinusExp node)
01760     {
01761         defaultIn(node);
01762     }
01763     public void inACharLiteral(ACharLiteral node)
01764     {
01765         defaultIn(node);
01766     }
01767     public void inACharPrimitiveType(ACharPrimitiveType node)
01768     {
01769         defaultIn(node);
01770     }
01771     public void inAColonExp(AColonExp node)
01772     {
01773         defaultIn(node);
01774     }
01775     public void inAComplementExp(AComplementExp node)
01776     {
01777         defaultIn(node);
01778     }
01779     public void inAComplementUnaryNotPlusMinusExp(AComplementUnaryNotPlusMinusExp node)
01780     {
01781         defaultIn(node);
01782     }
01783     public void inAConditionalExp(AConditionalExp node)
01784     {
01785         defaultIn(node);
01786     }
01787     public void inACpl(ACpl node)
01788     {
01789         defaultIn(node);
01790     }
01791     public void inADecIntLiteral(ADecIntLiteral node)
01792     {
01793         defaultIn(node);
01794     }
01795     public void inADecLongLiteral(ADecLongLiteral node)
01796     {
01797         defaultIn(node);
01798     }
01799     public void inADoubleLiteral(ADoubleLiteral node)
01800     {
01801         defaultIn(node);
01802     }
01803     public void inADoublePrimitiveType(ADoublePrimitiveType node)
01804     {
01805         defaultIn(node);
01806     }
01807     public void inAEndOfLineComment(AEndOfLineComment node)
01808     {
01809         defaultIn(node);
01810     }
01811     public void inAEqBitAndExp(AEqBitAndExp node)
01812     {
01813         defaultIn(node);
01814     }
01815     public void inAEqEqExp(AEqEqExp node)
01816     {
01817         defaultIn(node);
01818     }
01819     public void inAEqualBinOp(AEqualBinOp node)
01820     {
01821         defaultIn(node);
01822     }
01823     public void inAExpressionPropositionDefinition(AExpressionPropositionDefinition node)
01824     {
01825         defaultIn(node);
01826     }
01827     public void inAFalseLiteral(AFalseLiteral node)
01828     {
01829         defaultIn(node);
01830     }
01831     public void inAFieldAccessPrimaryExp(AFieldAccessPrimaryExp node)
01832     {
01833         defaultIn(node);
01834     }
01835     public void inAFloatLiteral(AFloatLiteral node)
01836     {
01837         defaultIn(node);
01838     }
01839     public void inAFloatPrimitiveType(AFloatPrimitiveType node)
01840     {
01841         defaultIn(node);
01842     }
01843     public void inAGreaterBinOp(AGreaterBinOp node)
01844     {
01845         defaultIn(node);
01846     }
01847     public void inAGreaterEqualBinOp(AGreaterEqualBinOp node)
01848     {
01849         defaultIn(node);
01850     }
01851     public void inAGreaterEqualRelExp(AGreaterEqualRelExp node)
01852     {
01853         defaultIn(node);
01854     }
01855     public void inAGreaterRelExp(AGreaterRelExp node)
01856     {
01857         defaultIn(node);
01858     }
01859     public void inAHexIntLiteral(AHexIntLiteral node)
01860     {
01861         defaultIn(node);
01862     }
01863     public void inAHexLongLiteral(AHexLongLiteral node)
01864     {
01865         defaultIn(node);
01866     }
01867     public void inAInclusiveOrAndExp(AInclusiveOrAndExp node)
01868     {
01869         defaultIn(node);
01870     }
01871     public void inAInstanceofExp(AInstanceofExp node)
01872     {
01873         defaultIn(node);
01874     }
01875     public void inAInstanceofRelExp(AInstanceofRelExp node)
01876     {
01877         defaultIn(node);
01878     }
01879     public void inAInstanceParams(AInstanceParams node)
01880     {
01881         defaultIn(node);
01882     }
01883     public void inAIntPrimitiveType(AIntPrimitiveType node)
01884     {
01885         defaultIn(node);
01886     }
01887     public void inAInvokePropositionDefinition(AInvokePropositionDefinition node)
01888     {
01889         defaultIn(node);
01890     }
01891     public void inALeftShiftExp(ALeftShiftExp node)
01892     {
01893         defaultIn(node);
01894     }
01895     public void inALessBinOp(ALessBinOp node)
01896     {
01897         defaultIn(node);
01898     }
01899     public void inALessEqualBinOp(ALessEqualBinOp node)
01900     {
01901         defaultIn(node);
01902     }
01903     public void inALessEqualRelExp(ALessEqualRelExp node)
01904     {
01905         defaultIn(node);
01906     }
01907     public void inALessRelExp(ALessRelExp node)
01908     {
01909         defaultIn(node);
01910     }
01911     public void inALiteralExp(ALiteralExp node)
01912     {
01913         defaultIn(node);
01914     }
01915     public void inALiteralPrimaryExp(ALiteralPrimaryExp node)
01916     {
01917         defaultIn(node);
01918     }
01919     public void inALocationPropositionDefinition(ALocationPropositionDefinition node)
01920     {
01921         defaultIn(node);
01922     }
01923     public void inALongPrimitiveType(ALongPrimitiveType node)
01924     {
01925         defaultIn(node);
01926     }
01927     public void inAMinusAddExp(AMinusAddExp node)
01928     {
01929         defaultIn(node);
01930     }
01931     public void inAMinusBinOp(AMinusBinOp node)
01932     {
01933         defaultIn(node);
01934     }
01935     public void inAMinusUnaryExp(AMinusUnaryExp node)
01936     {
01937         defaultIn(node);
01938     }
01939     public void inAMultAddExp(AMultAddExp node)
01940     {
01941         defaultIn(node);
01942     }
01943     public void inANameExp(ANameExp node)
01944     {
01945         defaultIn(node);
01946     }
01947     public void inANamePostfixExp(ANamePostfixExp node)
01948     {
01949         defaultIn(node);
01950     }
01951     public void inANavigationExp(ANavigationExp node)
01952     {
01953         defaultIn(node);
01954     }
01955     public void inANegativeExp(ANegativeExp node)
01956     {
01957         defaultIn(node);
01958     }
01959     public void inANeqEqExp(ANeqEqExp node)
01960     {
01961         defaultIn(node);
01962     }
01963     public void inANotEqualBinOp(ANotEqualBinOp node)
01964     {
01965         defaultIn(node);
01966     }
01967     public void inANullLiteral(ANullLiteral node)
01968     {
01969         defaultIn(node);
01970     }
01971     public void inAOctIntLiteral(AOctIntLiteral node)
01972     {
01973         defaultIn(node);
01974     }
01975     public void inAOctLongLiteral(AOctLongLiteral node)
01976     {
01977         defaultIn(node);
01978     }
01979     public void inAOrBinOp(AOrBinOp node)
01980     {
01981         defaultIn(node);
01982     }
01983     public void inAOrConditionalExp(AOrConditionalExp node)
01984     {
01985         defaultIn(node);
01986     }
01987     public void inAOrInclusiveOrExp(AOrInclusiveOrExp node)
01988     {
01989         defaultIn(node);
01990     }
01991     public void inAOrOrExp(AOrOrExp node)
01992     {
01993         defaultIn(node);
01994     }
01995     public void inAParamParamList(AParamParamList node)
01996     {
01997         defaultIn(node);
01998     }
01999     public void inAParamsParamList(AParamsParamList node)
02000     {
02001         defaultIn(node);
02002     }
02003     public void inAParenExp(AParenExp node)
02004     {
02005         defaultIn(node);
02006     }
02007     public void inAParenPrimaryExp(AParenPrimaryExp node)
02008     {
02009         defaultIn(node);
02010     }
02011     public void inAPlusAddExp(APlusAddExp node)
02012     {
02013         defaultIn(node);
02014     }
02015     public void inAPlusBinOp(APlusBinOp node)
02016     {
02017         defaultIn(node);
02018     }
02019     public void inAPlusUnaryExp(APlusUnaryExp node)
02020     {
02021         defaultIn(node);
02022     }
02023     public void inAPostfixUnaryNotPlusMinusExp(APostfixUnaryNotPlusMinusExp node)
02024     {
02025         defaultIn(node);
02026     }
02027     public void inAPrimaryPostfixExp(APrimaryPostfixExp node)
02028     {
02029         defaultIn(node);
02030     }
02031     public void inAQualifiedName(AQualifiedName node)
02032     {
02033         defaultIn(node);
02034     }
02035     public void inAQuestionConditionalExp(AQuestionConditionalExp node)
02036     {
02037         defaultIn(node);
02038     }
02039     public void inAQuestionExp(AQuestionExp node)
02040     {
02041         defaultIn(node);
02042     }
02043     public void inARelEqExp(ARelEqExp node)
02044     {
02045         defaultIn(node);
02046     }
02047     public void inAReturnPropositionDefinition(AReturnPropositionDefinition node)
02048     {
02049         defaultIn(node);
02050     }
02051     public void inAReturnValueExp(AReturnValueExp node)
02052     {
02053         defaultIn(node);
02054     }
02055     public void inAReturnValuePrimaryExp(AReturnValuePrimaryExp node)
02056     {
02057         defaultIn(node);
02058     }
02059     public void inAShiftLeftBinOp(AShiftLeftBinOp node)
02060     {
02061         defaultIn(node);
02062     }
02063     public void inAShiftRelExp(AShiftRelExp node)
02064     {
02065         defaultIn(node);
02066     }
02067     public void inAShortPrimitiveType(AShortPrimitiveType node)
02068     {
02069         defaultIn(node);
02070     }
02071     public void inASignedRightShiftExp(ASignedRightShiftExp node)
02072     {
02073         defaultIn(node);
02074     }
02075     public void inASignedShiftRightBinOp(ASignedShiftRightBinOp node)
02076     {
02077         defaultIn(node);
02078     }
02079     public void inASimpleName(ASimpleName node)
02080     {
02081         defaultIn(node);
02082     }
02083     public void inAStaticParams(AStaticParams node)
02084     {
02085         defaultIn(node);
02086     }
02087     public void inAStringLiteral(AStringLiteral node)
02088     {
02089         defaultIn(node);
02090     }
02091     public void inAStrongArrayNavigation(AStrongArrayNavigation node)
02092     {
02093         defaultIn(node);
02094     }
02095     public void inAStrongCastExp(AStrongCastExp node)
02096     {
02097         defaultIn(node);
02098     }
02099     public void inAStrongDivBinOp(AStrongDivBinOp node)
02100     {
02101         defaultIn(node);
02102     }
02103     public void inAStrongDivMultExp(AStrongDivMultExp node)
02104     {
02105         defaultIn(node);
02106     }
02107     public void inAStrongExpArrayAccess(AStrongExpArrayAccess node)
02108     {
02109         defaultIn(node);
02110     }
02111     public void inAStrongExpCastExp(AStrongExpCastExp node)
02112     {
02113         defaultIn(node);
02114     }
02115     public void inAStrongModBinOp(AStrongModBinOp node)
02116     {
02117         defaultIn(node);
02118     }
02119     public void inAStrongModMultExp(AStrongModMultExp node)
02120     {
02121         defaultIn(node);
02122     }
02123     public void inAStrongNameArrayAccess(AStrongNameArrayAccess node)
02124     {
02125         defaultIn(node);
02126     }
02127     public void inAStrongNameCastExp(AStrongNameCastExp node)
02128     {
02129         defaultIn(node);
02130     }
02131     public void inAStrongObjectFieldAccess(AStrongObjectFieldAccess node)
02132     {
02133         defaultIn(node);
02134     }
02135     public void inAStrongObjectNavigation(AStrongObjectNavigation node)
02136     {
02137         defaultIn(node);
02138     }
02139     public void inAStrongPrimitiveCastExp(AStrongPrimitiveCastExp node)
02140     {
02141         defaultIn(node);
02142     }
02143     public void inAThisExp(AThisExp node)
02144     {
02145         defaultIn(node);
02146     }
02147     public void inAThisPrimaryExp(AThisPrimaryExp node)
02148     {
02149         defaultIn(node);
02150     }
02151     public void inATimesBinOp(ATimesBinOp node)
02152     {
02153         defaultIn(node);
02154     }
02155     public void inATimesMultExp(ATimesMultExp node)
02156     {
02157         defaultIn(node);
02158     }
02159     public void inATrueLiteral(ATrueLiteral node)
02160     {
02161         defaultIn(node);
02162     }
02163     public void inAUnaryExpMultExp(AUnaryExpMultExp node)
02164     {
02165         defaultIn(node);
02166     }
02167     public void inAUnaryNotPlusMinusUnaryExp(AUnaryNotPlusMinusUnaryExp node)
02168     {
02169         defaultIn(node);
02170     }
02171     public void inAUnit(AUnit node)
02172     {
02173         defaultIn(node);
02174     }
02175     public void inAUnsignedRightShiftExp(AUnsignedRightShiftExp node)
02176     {
02177         defaultIn(node);
02178     }
02179     public void inAUnsignedShiftRightBinOp(AUnsignedShiftRightBinOp node)
02180     {
02181         defaultIn(node);
02182     }
02183     public void inAXorExclusiveOrExp(AXorExclusiveOrExp node)
02184     {
02185         defaultIn(node);
02186     }
02187     public void inAXorInclusiveOrExp(AXorInclusiveOrExp node)
02188     {
02189         defaultIn(node);
02190     }
02191     public void inStart(Start node)
02192     {
02193         defaultIn(node);
02194     }
02195     public void outAAddExpShiftExp(AAddExpShiftExp node)
02196     {
02197         defaultOut(node);
02198     }
02199     public void outAAndAndExp(AAndAndExp node)
02200     {
02201         defaultOut(node);
02202     }
02203     public void outAAndBinOp(AAndBinOp node)
02204     {
02205         defaultOut(node);
02206     }
02207     public void outAAndBitAndExp(AAndBitAndExp node)
02208     {
02209         defaultOut(node);
02210     }
02211     public void outAAndExclusiveOrExp(AAndExclusiveOrExp node)
02212     {
02213         defaultOut(node);
02214     }
02215     public void outAAndOrExp(AAndOrExp node)
02216     {
02217         defaultOut(node);
02218     }
02219     public void outAArrayAccessPrimaryExp(AArrayAccessPrimaryExp node)
02220     {
02221         defaultOut(node);
02222     }
02223     public void outABinaryExp(ABinaryExp node)
02224     {
02225         defaultOut(node);
02226     }
02227     public void outABitAndBinOp(ABitAndBinOp node)
02228     {
02229         defaultOut(node);
02230     }
02231     public void outABitComplementExp(ABitComplementExp node)
02232     {
02233         defaultOut(node);
02234     }
02235     public void outABitComplementUnaryNotPlusMinusExp(ABitComplementUnaryNotPlusMinusExp node)
02236     {
02237         defaultOut(node);
02238     }
02239     public void outABitOrBinOp(ABitOrBinOp node)
02240     {
02241         defaultOut(node);
02242     }
02243     public void outABitXorBinOp(ABitXorBinOp node)
02244     {
02245         defaultOut(node);
02246     }
02247     public void outABooleanPrimitiveType(ABooleanPrimitiveType node)
02248     {
02249         defaultOut(node);
02250     }
02251     public void outABytePrimitiveType(ABytePrimitiveType node)
02252     {
02253         defaultOut(node);
02254     }
02255     public void outACastUnaryNotPlusMinusExp(ACastUnaryNotPlusMinusExp node)
02256     {
02257         defaultOut(node);
02258     }
02259     public void outACharLiteral(ACharLiteral node)
02260     {
02261         defaultOut(node);
02262     }
02263     public void outACharPrimitiveType(ACharPrimitiveType node)
02264     {
02265         defaultOut(node);
02266     }
02267     public void outAColonExp(AColonExp node)
02268     {
02269         defaultOut(node);
02270     }
02271     public void outAComplementExp(AComplementExp node)
02272     {
02273         defaultOut(node);
02274     }
02275     public void outAComplementUnaryNotPlusMinusExp(AComplementUnaryNotPlusMinusExp node)
02276     {
02277         defaultOut(node);
02278     }
02279     public void outAConditionalExp(AConditionalExp node)
02280     {
02281         defaultOut(node);
02282     }
02283     public void outACpl(ACpl node)
02284     {
02285         defaultOut(node);
02286     }
02287     public void outADecIntLiteral(ADecIntLiteral node)
02288     {
02289         defaultOut(node);
02290     }
02291     public void outADecLongLiteral(ADecLongLiteral node)
02292     {
02293         defaultOut(node);
02294     }
02295     public void outADoubleLiteral(ADoubleLiteral node)
02296     {
02297         defaultOut(node);
02298     }
02299     public void outADoublePrimitiveType(ADoublePrimitiveType node)
02300     {
02301         defaultOut(node);
02302     }
02303     public void outAEndOfLineComment(AEndOfLineComment node)
02304     {
02305         defaultOut(node);
02306     }
02307     public void outAEqBitAndExp(AEqBitAndExp node)
02308     {
02309         defaultOut(node);
02310     }
02311     public void outAEqEqExp(AEqEqExp node)
02312     {
02313         defaultOut(node);
02314     }
02315     public void outAEqualBinOp(AEqualBinOp node)
02316     {
02317         defaultOut(node);
02318     }
02319     public void outAExpressionPropositionDefinition(AExpressionPropositionDefinition node)
02320     {
02321         defaultOut(node);
02322     }
02323     public void outAFalseLiteral(AFalseLiteral node)
02324     {
02325         defaultOut(node);
02326     }
02327     public void outAFieldAccessPrimaryExp(AFieldAccessPrimaryExp node)
02328     {
02329         defaultOut(node);
02330     }
02331     public void outAFloatLiteral(AFloatLiteral node)
02332     {
02333         defaultOut(node);
02334     }
02335     public void outAFloatPrimitiveType(AFloatPrimitiveType node)
02336     {
02337         defaultOut(node);
02338     }
02339     public void outAGreaterBinOp(AGreaterBinOp node)
02340     {
02341         defaultOut(node);
02342     }
02343     public void outAGreaterEqualBinOp(AGreaterEqualBinOp node)
02344     {
02345         defaultOut(node);
02346     }
02347     public void outAGreaterEqualRelExp(AGreaterEqualRelExp node)
02348     {
02349         defaultOut(node);
02350     }
02351     public void outAGreaterRelExp(AGreaterRelExp node)
02352     {
02353         defaultOut(node);
02354     }
02355     public void outAHexIntLiteral(AHexIntLiteral node)
02356     {
02357         defaultOut(node);
02358     }
02359     public void outAHexLongLiteral(AHexLongLiteral node)
02360     {
02361         defaultOut(node);
02362     }
02363     public void outAInclusiveOrAndExp(AInclusiveOrAndExp node)
02364     {
02365         defaultOut(node);
02366     }
02367     public void outAInstanceofExp(AInstanceofExp node)
02368     {
02369         defaultOut(node);
02370     }
02371     public void outAInstanceofRelExp(AInstanceofRelExp node)
02372     {
02373         defaultOut(node);
02374     }
02375     public void outAInstanceParams(AInstanceParams node)
02376     {
02377         defaultOut(node);
02378     }
02379     public void outAIntPrimitiveType(AIntPrimitiveType node)
02380     {
02381         defaultOut(node);
02382     }
02383     public void outAInvokePropositionDefinition(AInvokePropositionDefinition node)
02384     {
02385         defaultOut(node);
02386     }
02387     public void outALeftShiftExp(ALeftShiftExp node)
02388     {
02389         defaultOut(node);
02390     }
02391     public void outALessBinOp(ALessBinOp node)
02392     {
02393         defaultOut(node);
02394     }
02395     public void outALessEqualBinOp(ALessEqualBinOp node)
02396     {
02397         defaultOut(node);
02398     }
02399     public void outALessEqualRelExp(ALessEqualRelExp node)
02400     {
02401         defaultOut(node);
02402     }
02403     public void outALessRelExp(ALessRelExp node)
02404     {
02405         defaultOut(node);
02406     }
02407     public void outALiteralExp(ALiteralExp node)
02408     {
02409         defaultOut(node);
02410     }
02411     public void outALiteralPrimaryExp(ALiteralPrimaryExp node)
02412     {
02413         defaultOut(node);
02414     }
02415     public void outALocationPropositionDefinition(ALocationPropositionDefinition node)
02416     {
02417         defaultOut(node);
02418     }
02419     public void outALongPrimitiveType(ALongPrimitiveType node)
02420     {
02421         defaultOut(node);
02422     }
02423     public void outAMinusAddExp(AMinusAddExp node)
02424     {
02425         defaultOut(node);
02426     }
02427     public void outAMinusBinOp(AMinusBinOp node)
02428     {
02429         defaultOut(node);
02430     }
02431     public void outAMinusUnaryExp(AMinusUnaryExp node)
02432     {
02433         defaultOut(node);
02434     }
02435     public void outAMultAddExp(AMultAddExp node)
02436     {
02437         defaultOut(node);
02438     }
02439     public void outANameExp(ANameExp node)
02440     {
02441         defaultOut(node);
02442     }
02443     public void outANamePostfixExp(ANamePostfixExp node)
02444     {
02445         defaultOut(node);
02446     }
02447     public void outANavigationExp(ANavigationExp node)
02448     {
02449         defaultOut(node);
02450     }
02451     public void outANegativeExp(ANegativeExp node)
02452     {
02453         defaultOut(node);
02454     }
02455     public void outANeqEqExp(ANeqEqExp node)
02456     {
02457         defaultOut(node);
02458     }
02459     public void outANotEqualBinOp(ANotEqualBinOp node)
02460     {
02461         defaultOut(node);
02462     }
02463     public void outANullLiteral(ANullLiteral node)
02464     {
02465         defaultOut(node);
02466     }
02467     public void outAOctIntLiteral(AOctIntLiteral node)
02468     {
02469         defaultOut(node);
02470     }
02471     public void outAOctLongLiteral(AOctLongLiteral node)
02472     {
02473         defaultOut(node);
02474     }
02475     public void outAOrBinOp(AOrBinOp node)
02476     {
02477         defaultOut(node);
02478     }
02479     public void outAOrConditionalExp(AOrConditionalExp node)
02480     {
02481         defaultOut(node);
02482     }
02483     public void outAOrInclusiveOrExp(AOrInclusiveOrExp node)
02484     {
02485         defaultOut(node);
02486     }
02487     public void outAOrOrExp(AOrOrExp node)
02488     {
02489         defaultOut(node);
02490     }
02491     public void outAParamParamList(AParamParamList node)
02492     {
02493         defaultOut(node);
02494     }
02495     public void outAParamsParamList(AParamsParamList node)
02496     {
02497         defaultOut(node);
02498     }
02499     public void outAParenExp(AParenExp node)
02500     {
02501         defaultOut(node);
02502     }
02503     public void outAParenPrimaryExp(AParenPrimaryExp node)
02504     {
02505         defaultOut(node);
02506     }
02507     public void outAPlusAddExp(APlusAddExp node)
02508     {
02509         defaultOut(node);
02510     }
02511     public void outAPlusBinOp(APlusBinOp node)
02512     {
02513         defaultOut(node);
02514     }
02515     public void outAPlusUnaryExp(APlusUnaryExp node)
02516     {
02517         defaultOut(node);
02518     }
02519     public void outAPostfixUnaryNotPlusMinusExp(APostfixUnaryNotPlusMinusExp node)
02520     {
02521         defaultOut(node);
02522     }
02523     public void outAPrimaryPostfixExp(APrimaryPostfixExp node)
02524     {
02525         defaultOut(node);
02526     }
02527     public void outAQualifiedName(AQualifiedName node)
02528     {
02529         defaultOut(node);
02530     }
02531     public void outAQuestionConditionalExp(AQuestionConditionalExp node)
02532     {
02533         defaultOut(node);
02534     }
02535     public void outAQuestionExp(AQuestionExp node)
02536     {
02537         defaultOut(node);
02538     }
02539     public void outARelEqExp(ARelEqExp node)
02540     {
02541         defaultOut(node);
02542     }
02543     public void outAReturnPropositionDefinition(AReturnPropositionDefinition node)
02544     {
02545         defaultOut(node);
02546     }
02547     public void outAReturnValueExp(AReturnValueExp node)
02548     {
02549         defaultOut(node);
02550     }
02551     public void outAReturnValuePrimaryExp(AReturnValuePrimaryExp node)
02552     {
02553         defaultOut(node);
02554     }
02555     public void outAShiftLeftBinOp(AShiftLeftBinOp node)
02556     {
02557         defaultOut(node);
02558     }
02559     public void outAShiftRelExp(AShiftRelExp node)
02560     {
02561         defaultOut(node);
02562     }
02563     public void outAShortPrimitiveType(AShortPrimitiveType node)
02564     {
02565         defaultOut(node);
02566     }
02567     public void outASignedRightShiftExp(ASignedRightShiftExp node)
02568     {
02569         defaultOut(node);
02570     }
02571     public void outASignedShiftRightBinOp(ASignedShiftRightBinOp node)
02572     {
02573         defaultOut(node);
02574     }
02575     public void outASimpleName(ASimpleName node)
02576     {
02577         defaultOut(node);
02578     }
02579     public void outAStaticParams(AStaticParams node)
02580     {
02581         defaultOut(node);
02582     }
02583     public void outAStringLiteral(AStringLiteral node)
02584     {
02585         defaultOut(node);
02586     }
02587     public void outAStrongArrayNavigation(AStrongArrayNavigation node)
02588     {
02589         defaultOut(node);
02590     }
02591     public void outAStrongCastExp(AStrongCastExp node)
02592     {
02593         defaultOut(node);
02594     }
02595     public void outAStrongDivBinOp(AStrongDivBinOp node)
02596     {
02597         defaultOut(node);
02598     }
02599     public void outAStrongDivMultExp(AStrongDivMultExp node)
02600     {
02601         defaultOut(node);
02602     }
02603     public void outAStrongExpArrayAccess(AStrongExpArrayAccess node)
02604     {
02605         defaultOut(node);
02606     }
02607     public void outAStrongExpCastExp(AStrongExpCastExp node)
02608     {
02609         defaultOut(node);
02610     }
02611     public void outAStrongModBinOp(AStrongModBinOp node)
02612     {
02613         defaultOut(node);
02614     }
02615     public void outAStrongModMultExp(AStrongModMultExp node)
02616     {
02617         defaultOut(node);
02618     }
02619     public void outAStrongNameArrayAccess(AStrongNameArrayAccess node)
02620     {
02621         defaultOut(node);
02622     }
02623     public void outAStrongNameCastExp(AStrongNameCastExp node)
02624     {
02625         defaultOut(node);
02626     }
02627     public void outAStrongObjectFieldAccess(AStrongObjectFieldAccess node)
02628     {
02629         defaultOut(node);
02630     }
02631     public void outAStrongObjectNavigation(AStrongObjectNavigation node)
02632     {
02633         defaultOut(node);
02634     }
02635     public void outAStrongPrimitiveCastExp(AStrongPrimitiveCastExp node)
02636     {
02637         defaultOut(node);
02638     }
02639     public void outAThisExp(AThisExp node)
02640     {
02641         defaultOut(node);
02642     }
02643     public void outAThisPrimaryExp(AThisPrimaryExp node)
02644     {
02645         defaultOut(node);
02646     }
02647     public void outATimesBinOp(ATimesBinOp node)
02648     {
02649         defaultOut(node);
02650     }
02651     public void outATimesMultExp(ATimesMultExp node)
02652     {
02653         defaultOut(node);
02654     }
02655     public void outATrueLiteral(ATrueLiteral node)
02656     {
02657         defaultOut(node);
02658     }
02659     public void outAUnaryExpMultExp(AUnaryExpMultExp node)
02660     {
02661         defaultOut(node);
02662     }
02663     public void outAUnaryNotPlusMinusUnaryExp(AUnaryNotPlusMinusUnaryExp node)
02664     {
02665         defaultOut(node);
02666     }
02667     public void outAUnit(AUnit node)
02668     {
02669         defaultOut(node);
02670     }
02671     public void outAUnsignedRightShiftExp(AUnsignedRightShiftExp node)
02672     {
02673         defaultOut(node);
02674     }
02675     public void outAUnsignedShiftRightBinOp(AUnsignedShiftRightBinOp node)
02676     {
02677         defaultOut(node);
02678     }
02679     public void outAXorExclusiveOrExp(AXorExclusiveOrExp node)
02680     {
02681         defaultOut(node);
02682     }
02683     public void outAXorInclusiveOrExp(AXorInclusiveOrExp node)
02684     {
02685         defaultOut(node);
02686     }
02687     public void outStart(Start node)
02688     {
02689         defaultOut(node);
02690     }
02691 }