DepthFirstAdapter.java Source File

00001 package edu.ksu.cis.bandera.abstraction.specification.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 /* This file was generated by SableCC (http://www.sable.mcgill.ca/sablecc/). */
00037 
00038 import java.util.*;
00039 import edu.ksu.cis.bandera.abstraction.specification.node.*;
00040 
00041 public class DepthFirstAdapter extends AnalysisAdapter
00042 {
00043     public void caseAAbstractFunction(AAbstractFunction node)
00044     {
00045         inAAbstractFunction(node);
00046         if(node.getAbstract() != null)
00047         {
00048             node.getAbstract().apply(this);
00049         }
00050         if(node.getLParen() != null)
00051         {
00052             node.getLParen().apply(this);
00053         }
00054         if(node.getId() != null)
00055         {
00056             node.getId().apply(this);
00057         }
00058         if(node.getRParen() != null)
00059         {
00060             node.getRParen().apply(this);
00061         }
00062         if(node.getBegin() != null)
00063         {
00064             node.getBegin().apply(this);
00065         }
00066         {
00067             Object temp[] = node.getAbstractDef().toArray();
00068             for(int i = 0; i < temp.length; i++)
00069             {
00070                 ((PAbstractDef) temp[i]).apply(this);
00071             }
00072         }
00073         if(node.getEnd() != null)
00074         {
00075             node.getEnd().apply(this);
00076         }
00077         outAAbstractFunction(node);
00078     }
00079     public void caseAAddExpShiftExp(AAddExpShiftExp node)
00080     {
00081         inAAddExpShiftExp(node);
00082         if(node.getAddExp() != null)
00083         {
00084             node.getAddExp().apply(this);
00085         }
00086         outAAddExpShiftExp(node);
00087     }
00088     public void caseAAndAndExp(AAndAndExp node)
00089     {
00090         inAAndAndExp(node);
00091         if(node.getAndExp() != null)
00092         {
00093             node.getAndExp().apply(this);
00094         }
00095         if(node.getAnd() != null)
00096         {
00097             node.getAnd().apply(this);
00098         }
00099         if(node.getInclusiveOrExp() != null)
00100         {
00101             node.getInclusiveOrExp().apply(this);
00102         }
00103         outAAndAndExp(node);
00104     }
00105     public void caseAAndBitAndExp(AAndBitAndExp node)
00106     {
00107         inAAndBitAndExp(node);
00108         if(node.getBitAndExp() != null)
00109         {
00110             node.getBitAndExp().apply(this);
00111         }
00112         if(node.getBitAnd() != null)
00113         {
00114             node.getBitAnd().apply(this);
00115         }
00116         if(node.getEqExp() != null)
00117         {
00118             node.getEqExp().apply(this);
00119         }
00120         outAAndBitAndExp(node);
00121     }
00122     public void caseAAndExclusiveOrExp(AAndExclusiveOrExp node)
00123     {
00124         inAAndExclusiveOrExp(node);
00125         if(node.getBitAndExp() != null)
00126         {
00127             node.getBitAndExp().apply(this);
00128         }
00129         outAAndExclusiveOrExp(node);
00130     }
00131     public void caseAAndOrExp(AAndOrExp node)
00132     {
00133         inAAndOrExp(node);
00134         if(node.getAndExp() != null)
00135         {
00136             node.getAndExp().apply(this);
00137         }
00138         outAAndOrExp(node);
00139     }
00140     public void caseAAnyAbstractDef(AAnyAbstractDef node)
00141     {
00142         inAAnyAbstractDef(node);
00143         if(node.getAny() != null)
00144         {
00145             node.getAny().apply(this);
00146         }
00147         if(node.getRightarrow() != null)
00148         {
00149             node.getRightarrow().apply(this);
00150         }
00151         if(node.getId() != null)
00152         {
00153             node.getId().apply(this);
00154         }
00155         if(node.getSemicolon() != null)
00156         {
00157             node.getSemicolon().apply(this);
00158         }
00159         outAAnyAbstractDef(node);
00160     }
00161     public void caseAAnyAnyId(AAnyAnyId node)
00162     {
00163         inAAnyAnyId(node);
00164         if(node.getAny() != null)
00165         {
00166             node.getAny().apply(this);
00167         }
00168         outAAnyAnyId(node);
00169     }
00170     public void caseAAnyPattern(AAnyPattern node)
00171     {
00172         inAAnyPattern(node);
00173         if(node.getAny() != null)
00174         {
00175             node.getAny().apply(this);
00176         }
00177         if(node.getRightarrow() != null)
00178         {
00179             node.getRightarrow().apply(this);
00180         }
00181         if(node.getTokenTokenSet() != null)
00182         {
00183             node.getTokenTokenSet().apply(this);
00184         }
00185         if(node.getSemicolon() != null)
00186         {
00187             node.getSemicolon().apply(this);
00188         }
00189         outAAnyPattern(node);
00190     }
00191     public void caseABitComplementUnaryNotPlusMinusExp(ABitComplementUnaryNotPlusMinusExp node)
00192     {
00193         inABitComplementUnaryNotPlusMinusExp(node);
00194         if(node.getBitComplement() != null)
00195         {
00196             node.getBitComplement().apply(this);
00197         }
00198         if(node.getUnaryExp() != null)
00199         {
00200             node.getUnaryExp().apply(this);
00201         }
00202         outABitComplementUnaryNotPlusMinusExp(node);
00203     }
00204     public void caseAComplementUnaryNotPlusMinusExp(AComplementUnaryNotPlusMinusExp node)
00205     {
00206         inAComplementUnaryNotPlusMinusExp(node);
00207         if(node.getNot() != null)
00208         {
00209             node.getNot().apply(this);
00210         }
00211         if(node.getUnaryExp() != null)
00212         {
00213             node.getUnaryExp().apply(this);
00214         }
00215         outAComplementUnaryNotPlusMinusExp(node);
00216     }
00217     public void caseADecIntLiteral(ADecIntLiteral node)
00218     {
00219         inADecIntLiteral(node);
00220         if(node.getDecIntLiteral() != null)
00221         {
00222             node.getDecIntLiteral().apply(this);
00223         }
00224         outADecIntLiteral(node);
00225     }
00226     public void caseADecLongLiteral(ADecLongLiteral node)
00227     {
00228         inADecLongLiteral(node);
00229         if(node.getDecLongLiteral() != null)
00230         {
00231             node.getDecLongLiteral().apply(this);
00232         }
00233         outADecLongLiteral(node);
00234     }
00235     public void caseADefaultToken(ADefaultToken node)
00236     {
00237         inADefaultToken(node);
00238         if(node.getDefault() != null)
00239         {
00240             node.getDefault().apply(this);
00241         }
00242         if(node.getEq() != null)
00243         {
00244             node.getEq().apply(this);
00245         }
00246         if(node.getId() != null)
00247         {
00248             node.getId().apply(this);
00249         }
00250         if(node.getSemicolon() != null)
00251         {
00252             node.getSemicolon().apply(this);
00253         }
00254         outADefaultToken(node);
00255     }
00256     public void caseADivMultExp(ADivMultExp node)
00257     {
00258         inADivMultExp(node);
00259         if(node.getMultExp() != null)
00260         {
00261             node.getMultExp().apply(this);
00262         }
00263         if(node.getDiv() != null)
00264         {
00265             node.getDiv().apply(this);
00266         }
00267         if(node.getUnaryExp() != null)
00268         {
00269             node.getUnaryExp().apply(this);
00270         }
00271         outADivMultExp(node);
00272     }
00273     public void caseADivOp(ADivOp node)
00274     {
00275         inADivOp(node);
00276         if(node.getDiv() != null)
00277         {
00278             node.getDiv().apply(this);
00279         }
00280         outADivOp(node);
00281     }
00282     public void caseADoubleLiteral(ADoubleLiteral node)
00283     {
00284         inADoubleLiteral(node);
00285         if(node.getDoubleLiteral() != null)
00286         {
00287             node.getDoubleLiteral().apply(this);
00288         }
00289         outADoubleLiteral(node);
00290     }
00291     public void caseAEqBitAndExp(AEqBitAndExp node)
00292     {
00293         inAEqBitAndExp(node);
00294         if(node.getEqExp() != null)
00295         {
00296             node.getEqExp().apply(this);
00297         }
00298         outAEqBitAndExp(node);
00299     }
00300     public void caseAEqEqExp(AEqEqExp node)
00301     {
00302         inAEqEqExp(node);
00303         if(node.getEqExp() != null)
00304         {
00305             node.getEqExp().apply(this);
00306         }
00307         if(node.getEqual() != null)
00308         {
00309             node.getEqual().apply(this);
00310         }
00311         if(node.getRelExp() != null)
00312         {
00313             node.getRelExp().apply(this);
00314         }
00315         outAEqEqExp(node);
00316     }
00317     public void caseAEqualTOp(AEqualTOp node)
00318     {
00319         inAEqualTOp(node);
00320         if(node.getEqual() != null)
00321         {
00322             node.getEqual().apply(this);
00323         }
00324         outAEqualTOp(node);
00325     }
00326     public void caseAExp(AExp node)
00327     {
00328         inAExp(node);
00329         if(node.getConditionalExp() != null)
00330         {
00331             node.getConditionalExp().apply(this);
00332         }
00333         outAExp(node);
00334     }
00335     public void caseAExpAbstractDef(AExpAbstractDef node)
00336     {
00337         inAExpAbstractDef(node);
00338         if(node.getExp() != null)
00339         {
00340             node.getExp().apply(this);
00341         }
00342         if(node.getRightarrow() != null)
00343         {
00344             node.getRightarrow().apply(this);
00345         }
00346         if(node.getId() != null)
00347         {
00348             node.getId().apply(this);
00349         }
00350         if(node.getSemicolon() != null)
00351         {
00352             node.getSemicolon().apply(this);
00353         }
00354         outAExpAbstractDef(node);
00355     }
00356     public void caseAFloatLiteral(AFloatLiteral node)
00357     {
00358         inAFloatLiteral(node);
00359         if(node.getFloatLiteral() != null)
00360         {
00361             node.getFloatLiteral().apply(this);
00362         }
00363         outAFloatLiteral(node);
00364     }
00365     public void caseAGreaterEqualRelExp(AGreaterEqualRelExp node)
00366     {
00367         inAGreaterEqualRelExp(node);
00368         if(node.getRelExp() != null)
00369         {
00370             node.getRelExp().apply(this);
00371         }
00372         if(node.getGreaterEqual() != null)
00373         {
00374             node.getGreaterEqual().apply(this);
00375         }
00376         if(node.getShiftExp() != null)
00377         {
00378             node.getShiftExp().apply(this);
00379         }
00380         outAGreaterEqualRelExp(node);
00381     }
00382     public void caseAGreaterEqualTOp(AGreaterEqualTOp node)
00383     {
00384         inAGreaterEqualTOp(node);
00385         if(node.getGreaterEqual() != null)
00386         {
00387             node.getGreaterEqual().apply(this);
00388         }
00389         outAGreaterEqualTOp(node);
00390     }
00391     public void caseAGreaterRelExp(AGreaterRelExp node)
00392     {
00393         inAGreaterRelExp(node);
00394         if(node.getRelExp() != null)
00395         {
00396             node.getRelExp().apply(this);
00397         }
00398         if(node.getGreater() != null)
00399         {
00400             node.getGreater().apply(this);
00401         }
00402         if(node.getShiftExp() != null)
00403         {
00404             node.getShiftExp().apply(this);
00405         }
00406         outAGreaterRelExp(node);
00407     }
00408     public void caseAGreaterTOp(AGreaterTOp node)
00409     {
00410         inAGreaterTOp(node);
00411         if(node.getGreater() != null)
00412         {
00413             node.getGreater().apply(this);
00414         }
00415         outAGreaterTOp(node);
00416     }
00417     public void caseAHexIntLiteral(AHexIntLiteral node)
00418     {
00419         inAHexIntLiteral(node);
00420         if(node.getHexIntLiteral() != null)
00421         {
00422             node.getHexIntLiteral().apply(this);
00423         }
00424         outAHexIntLiteral(node);
00425     }
00426     public void caseAHexLongLiteral(AHexLongLiteral node)
00427     {
00428         inAHexLongLiteral(node);
00429         if(node.getHexLongLiteral() != null)
00430         {
00431             node.getHexLongLiteral().apply(this);
00432         }
00433         outAHexLongLiteral(node);
00434     }
00435     public void caseAIdAnyId(AIdAnyId node)
00436     {
00437         inAIdAnyId(node);
00438         if(node.getId() != null)
00439         {
00440             node.getId().apply(this);
00441         }
00442         outAIdAnyId(node);
00443     }
00444     public void caseAIdIdList(AIdIdList node)
00445     {
00446         inAIdIdList(node);
00447         if(node.getId() != null)
00448         {
00449             node.getId().apply(this);
00450         }
00451         outAIdIdList(node);
00452     }
00453     public void caseAIdPrimaryExp(AIdPrimaryExp node)
00454     {
00455         inAIdPrimaryExp(node);
00456         if(node.getId() != null)
00457         {
00458             node.getId().apply(this);
00459         }
00460         outAIdPrimaryExp(node);
00461     }
00462     public void caseAIdSet(AIdSet node)
00463     {
00464         inAIdSet(node);
00465         if(node.getLBrace() != null)
00466         {
00467             node.getLBrace().apply(this);
00468         }
00469         if(node.getIdList() != null)
00470         {
00471             node.getIdList().apply(this);
00472         }
00473         if(node.getRBrace() != null)
00474         {
00475             node.getRBrace().apply(this);
00476         }
00477         outAIdSet(node);
00478     }
00479     public void caseAIdsIdList(AIdsIdList node)
00480     {
00481         inAIdsIdList(node);
00482         if(node.getIdList() != null)
00483         {
00484             node.getIdList().apply(this);
00485         }
00486         if(node.getComma() != null)
00487         {
00488             node.getComma().apply(this);
00489         }
00490         if(node.getId() != null)
00491         {
00492             node.getId().apply(this);
00493         }
00494         outAIdsIdList(node);
00495     }
00496     public void caseAInclusiveOrAndExp(AInclusiveOrAndExp node)
00497     {
00498         inAInclusiveOrAndExp(node);
00499         if(node.getInclusiveOrExp() != null)
00500         {
00501             node.getInclusiveOrExp().apply(this);
00502         }
00503         outAInclusiveOrAndExp(node);
00504     }
00505     public void caseAIntegralType(AIntegralType node)
00506     {
00507         inAIntegralType(node);
00508         if(node.getIntegral() != null)
00509         {
00510             node.getIntegral().apply(this);
00511         }
00512         outAIntegralType(node);
00513     }
00514     public void caseALeftShiftExp(ALeftShiftExp node)
00515     {
00516         inALeftShiftExp(node);
00517         if(node.getShiftExp() != null)
00518         {
00519             node.getShiftExp().apply(this);
00520         }
00521         if(node.getShiftLeft() != null)
00522         {
00523             node.getShiftLeft().apply(this);
00524         }
00525         if(node.getAddExp() != null)
00526         {
00527             node.getAddExp().apply(this);
00528         }
00529         outALeftShiftExp(node);
00530     }
00531     public void caseALessEqualRelExp(ALessEqualRelExp node)
00532     {
00533         inALessEqualRelExp(node);
00534         if(node.getRelExp() != null)
00535         {
00536             node.getRelExp().apply(this);
00537         }
00538         if(node.getLessEqual() != null)
00539         {
00540             node.getLessEqual().apply(this);
00541         }
00542         if(node.getShiftExp() != null)
00543         {
00544             node.getShiftExp().apply(this);
00545         }
00546         outALessEqualRelExp(node);
00547     }
00548     public void caseALessEqualTOp(ALessEqualTOp node)
00549     {
00550         inALessEqualTOp(node);
00551         if(node.getLessEqual() != null)
00552         {
00553             node.getLessEqual().apply(this);
00554         }
00555         outALessEqualTOp(node);
00556     }
00557     public void caseALessRelExp(ALessRelExp node)
00558     {
00559         inALessRelExp(node);
00560         if(node.getRelExp() != null)
00561         {
00562             node.getRelExp().apply(this);
00563         }
00564         if(node.getLess() != null)
00565         {
00566             node.getLess().apply(this);
00567         }
00568         if(node.getShiftExp() != null)
00569         {
00570             node.getShiftExp().apply(this);
00571         }
00572         outALessRelExp(node);
00573     }
00574     public void caseALessTOp(ALessTOp node)
00575     {
00576         inALessTOp(node);
00577         if(node.getLess() != null)
00578         {
00579             node.getLess().apply(this);
00580         }
00581         outALessTOp(node);
00582     }
00583     public void caseALiteralPrimaryExp(ALiteralPrimaryExp node)
00584     {
00585         inALiteralPrimaryExp(node);
00586         if(node.getLiteral() != null)
00587         {
00588             node.getLiteral().apply(this);
00589         }
00590         outALiteralPrimaryExp(node);
00591     }
00592     public void caseAMinusAddExp(AMinusAddExp node)
00593     {
00594         inAMinusAddExp(node);
00595         if(node.getAddExp() != null)
00596         {
00597             node.getAddExp().apply(this);
00598         }
00599         if(node.getMinus() != null)
00600         {
00601             node.getMinus().apply(this);
00602         }
00603         if(node.getMultExp() != null)
00604         {
00605             node.getMultExp().apply(this);
00606         }
00607         outAMinusAddExp(node);
00608     }
00609     public void caseAMinusOp(AMinusOp node)
00610     {
00611         inAMinusOp(node);
00612         if(node.getMinus() != null)
00613         {
00614             node.getMinus().apply(this);
00615         }
00616         outAMinusOp(node);
00617     }
00618     public void caseAMinusUnaryExp(AMinusUnaryExp node)
00619     {
00620         inAMinusUnaryExp(node);
00621         if(node.getMinus() != null)
00622         {
00623             node.getMinus().apply(this);
00624         }
00625         if(node.getUnaryExp() != null)
00626         {
00627             node.getUnaryExp().apply(this);
00628         }
00629         outAMinusUnaryExp(node);
00630     }
00631     public void caseAModMultExp(AModMultExp node)
00632     {
00633         inAModMultExp(node);
00634         if(node.getMultExp() != null)
00635         {
00636             node.getMultExp().apply(this);
00637         }
00638         if(node.getMod() != null)
00639         {
00640             node.getMod().apply(this);
00641         }
00642         if(node.getUnaryExp() != null)
00643         {
00644             node.getUnaryExp().apply(this);
00645         }
00646         outAModMultExp(node);
00647     }
00648     public void caseAModOp(AModOp node)
00649     {
00650         inAModOp(node);
00651         if(node.getMod() != null)
00652         {
00653             node.getMod().apply(this);
00654         }
00655         outAModOp(node);
00656     }
00657     public void caseAMultAddExp(AMultAddExp node)
00658     {
00659         inAMultAddExp(node);
00660         if(node.getMultExp() != null)
00661         {
00662             node.getMultExp().apply(this);
00663         }
00664         outAMultAddExp(node);
00665     }
00666     public void caseANeqEqExp(ANeqEqExp node)
00667     {
00668         inANeqEqExp(node);
00669         if(node.getEqExp() != null)
00670         {
00671             node.getEqExp().apply(this);
00672         }
00673         if(node.getNotEqual() != null)
00674         {
00675             node.getNotEqual().apply(this);
00676         }
00677         if(node.getRelExp() != null)
00678         {
00679             node.getRelExp().apply(this);
00680         }
00681         outANeqEqExp(node);
00682     }
00683     public void caseANotEqualTOp(ANotEqualTOp node)
00684     {
00685         inANotEqualTOp(node);
00686         if(node.getNotEqual() != null)
00687         {
00688             node.getNotEqual().apply(this);
00689         }
00690         outANotEqualTOp(node);
00691     }
00692     public void caseAOctIntLiteral(AOctIntLiteral node)
00693     {
00694         inAOctIntLiteral(node);
00695         if(node.getOctIntLiteral() != null)
00696         {
00697             node.getOctIntLiteral().apply(this);
00698         }
00699         outAOctIntLiteral(node);
00700     }
00701     public void caseAOctLongLiteral(AOctLongLiteral node)
00702     {
00703         inAOctLongLiteral(node);
00704         if(node.getOctLongLiteral() != null)
00705         {
00706             node.getOctLongLiteral().apply(this);
00707         }
00708         outAOctLongLiteral(node);
00709     }
00710     public void caseAOne2oneSet(AOne2oneSet node)
00711     {
00712         inAOne2oneSet(node);
00713         if(node.getOne2one() != null)
00714         {
00715             node.getOne2one().apply(this);
00716         }
00717         if(node.getEq() != null)
00718         {
00719             node.getEq().apply(this);
00720         }
00721         if(node.getLBrace() != null)
00722         {
00723             node.getLBrace().apply(this);
00724         }
00725         if(node.getIdList() != null)
00726         {
00727             node.getIdList().apply(this);
00728         }
00729         if(node.getRBrace() != null)
00730         {
00731             node.getRBrace().apply(this);
00732         }
00733         if(node.getSemicolon() != null)
00734         {
00735             node.getSemicolon().apply(this);
00736         }
00737         outAOne2oneSet(node);
00738     }
00739     public void caseAOperator(AOperator node)
00740     {
00741         inAOperator(node);
00742         if(node.getOperator() != null)
00743         {
00744             node.getOperator().apply(this);
00745         }
00746         if(node.getOp() != null)
00747         {
00748             node.getOp().apply(this);
00749         }
00750         if(node.getId() != null)
00751         {
00752             node.getId().apply(this);
00753         }
00754         if(node.getBegin() != null)
00755         {
00756             node.getBegin().apply(this);
00757         }
00758         {
00759             Object temp[] = node.getPattern().toArray();
00760             for(int i = 0; i < temp.length; i++)
00761             {
00762                 ((PPattern) temp[i]).apply(this);
00763             }
00764         }
00765         if(node.getEnd() != null)
00766         {
00767             node.getEnd().apply(this);
00768         }
00769         outAOperator(node);
00770     }
00771     public void caseAOperatorOperatorTest(AOperatorOperatorTest node)
00772     {
00773         inAOperatorOperatorTest(node);
00774         if(node.getOperator() != null)
00775         {
00776             node.getOperator().apply(this);
00777         }
00778         outAOperatorOperatorTest(node);
00779     }
00780     public void caseAOrConditionalExp(AOrConditionalExp node)
00781     {
00782         inAOrConditionalExp(node);
00783         if(node.getOrExp() != null)
00784         {
00785             node.getOrExp().apply(this);
00786         }
00787         outAOrConditionalExp(node);
00788     }
00789     public void caseAOrInclusiveOrExp(AOrInclusiveOrExp node)
00790     {
00791         inAOrInclusiveOrExp(node);
00792         if(node.getInclusiveOrExp() != null)
00793         {
00794             node.getInclusiveOrExp().apply(this);
00795         }
00796         if(node.getBitOr() != null)
00797         {
00798             node.getBitOr().apply(this);
00799         }
00800         if(node.getExclusiveOrExp() != null)
00801         {
00802             node.getExclusiveOrExp().apply(this);
00803         }
00804         outAOrInclusiveOrExp(node);
00805     }
00806     public void caseAOrOrExp(AOrOrExp node)
00807     {
00808         inAOrOrExp(node);
00809         if(node.getOrExp() != null)
00810         {
00811             node.getOrExp().apply(this);
00812         }
00813         if(node.getOr() != null)
00814         {
00815             node.getOr().apply(this);
00816         }
00817         if(node.getAndExp() != null)
00818         {
00819             node.getAndExp().apply(this);
00820         }
00821         outAOrOrExp(node);
00822     }
00823     public void caseAParenPrimaryExp(AParenPrimaryExp node)
00824     {
00825         inAParenPrimaryExp(node);
00826         if(node.getLParen() != null)
00827         {
00828             node.getLParen().apply(this);
00829         }
00830         if(node.getExp() != null)
00831         {
00832             node.getExp().apply(this);
00833         }
00834         if(node.getRParen() != null)
00835         {
00836             node.getRParen().apply(this);
00837         }
00838         outAParenPrimaryExp(node);
00839     }
00840     public void caseAPatternPattern(APatternPattern node)
00841     {
00842         inAPatternPattern(node);
00843         if(node.getLParen() != null)
00844         {
00845             node.getLParen().apply(this);
00846         }
00847         if(node.getLId() != null)
00848         {
00849             node.getLId().apply(this);
00850         }
00851         if(node.getComma() != null)
00852         {
00853             node.getComma().apply(this);
00854         }
00855         if(node.getRId() != null)
00856         {
00857             node.getRId().apply(this);
00858         }
00859         if(node.getRParen() != null)
00860         {
00861             node.getRParen().apply(this);
00862         }
00863         if(node.getRightarrow() != null)
00864         {
00865             node.getRightarrow().apply(this);
00866         }
00867         if(node.getTokenTokenSet() != null)
00868         {
00869             node.getTokenTokenSet().apply(this);
00870         }
00871         if(node.getSemicolon() != null)
00872         {
00873             node.getSemicolon().apply(this);
00874         }
00875         outAPatternPattern(node);
00876     }
00877     public void caseAPlusAddExp(APlusAddExp node)
00878     {
00879         inAPlusAddExp(node);
00880         if(node.getAddExp() != null)
00881         {
00882             node.getAddExp().apply(this);
00883         }
00884         if(node.getPlus() != null)
00885         {
00886             node.getPlus().apply(this);
00887         }
00888         if(node.getMultExp() != null)
00889         {
00890             node.getMultExp().apply(this);
00891         }
00892         outAPlusAddExp(node);
00893     }
00894     public void caseAPlusOp(APlusOp node)
00895     {
00896         inAPlusOp(node);
00897         if(node.getPlus() != null)
00898         {
00899             node.getPlus().apply(this);
00900         }
00901         outAPlusOp(node);
00902     }
00903     public void caseAPlusUnaryExp(APlusUnaryExp node)
00904     {
00905         inAPlusUnaryExp(node);
00906         if(node.getPlus() != null)
00907         {
00908             node.getPlus().apply(this);
00909         }
00910         if(node.getUnaryExp() != null)
00911         {
00912             node.getUnaryExp().apply(this);
00913         }
00914         outAPlusUnaryExp(node);
00915     }
00916     public void caseAPrimaryUnaryNotPlusMinusExp(APrimaryUnaryNotPlusMinusExp node)
00917     {
00918         inAPrimaryUnaryNotPlusMinusExp(node);
00919         if(node.getPrimaryExp() != null)
00920         {
00921             node.getPrimaryExp().apply(this);
00922         }
00923         outAPrimaryUnaryNotPlusMinusExp(node);
00924     }
00925     public void caseAQuestionConditionalExp(AQuestionConditionalExp node)
00926     {
00927         inAQuestionConditionalExp(node);
00928         if(node.getOrExp() != null)
00929         {
00930             node.getOrExp().apply(this);
00931         }
00932         if(node.getQuestion() != null)
00933         {
00934             node.getQuestion().apply(this);
00935         }
00936         if(node.getTrueExp() != null)
00937         {
00938             node.getTrueExp().apply(this);
00939         }
00940         if(node.getColon() != null)
00941         {
00942             node.getColon().apply(this);
00943         }
00944         if(node.getFalseExp() != null)
00945         {
00946             node.getFalseExp().apply(this);
00947         }
00948         outAQuestionConditionalExp(node);
00949     }
00950     public void caseARealType(ARealType node)
00951     {
00952         inARealType(node);
00953         if(node.getReal() != null)
00954         {
00955             node.getReal().apply(this);
00956         }
00957         outARealType(node);
00958     }
00959     public void caseARelEqExp(ARelEqExp node)
00960     {
00961         inARelEqExp(node);
00962         if(node.getRelExp() != null)
00963         {
00964             node.getRelExp().apply(this);
00965         }
00966         outARelEqExp(node);
00967     }
00968     public void caseAShiftRelExp(AShiftRelExp node)
00969     {
00970         inAShiftRelExp(node);
00971         if(node.getShiftExp() != null)
00972         {
00973             node.getShiftExp().apply(this);
00974         }
00975         outAShiftRelExp(node);
00976     }
00977     public void caseASignedRightShiftExp(ASignedRightShiftExp node)
00978     {
00979         inASignedRightShiftExp(node);
00980         if(node.getShiftExp() != null)
00981         {
00982             node.getShiftExp().apply(this);
00983         }
00984         if(node.getSignedShiftRight() != null)
00985         {
00986             node.getSignedShiftRight().apply(this);
00987         }
00988         if(node.getAddExp() != null)
00989         {
00990             node.getAddExp().apply(this);
00991         }
00992         outASignedRightShiftExp(node);
00993     }
00994     public void caseATest(ATest node)
00995     {
00996         inATest(node);
00997         if(node.getTest() != null)
00998         {
00999             node.getTest().apply(this);
01000         }
01001         if(node.getTOp() != null)
01002         {
01003             node.getTOp().apply(this);
01004         }
01005         if(node.getId() != null)
01006         {
01007             node.getId().apply(this);
01008         }
01009         if(node.getBegin() != null)
01010         {
01011             node.getBegin().apply(this);
01012         }
01013         {
01014             Object temp[] = node.getPattern().toArray();
01015             for(int i = 0; i < temp.length; i++)
01016             {
01017                 ((PPattern) temp[i]).apply(this);
01018             }
01019         }
01020         if(node.getEnd() != null)
01021         {
01022             node.getEnd().apply(this);
01023         }
01024         outATest(node);
01025     }
01026     public void caseATestOperatorTest(ATestOperatorTest node)
01027     {
01028         inATestOperatorTest(node);
01029         if(node.getTest() != null)
01030         {
01031             node.getTest().apply(this);
01032         }
01033         outATestOperatorTest(node);
01034     }
01035     public void caseATimesMultExp(ATimesMultExp node)
01036     {
01037         inATimesMultExp(node);
01038         if(node.getMultExp() != null)
01039         {
01040             node.getMultExp().apply(this);
01041         }
01042         if(node.getTimes() != null)
01043         {
01044             node.getTimes().apply(this);
01045         }
01046         if(node.getUnaryExp() != null)
01047         {
01048             node.getUnaryExp().apply(this);
01049         }
01050         outATimesMultExp(node);
01051     }
01052     public void caseATimesOp(ATimesOp node)
01053     {
01054         inATimesOp(node);
01055         if(node.getTimes() != null)
01056         {
01057             node.getTimes().apply(this);
01058         }
01059         outATimesOp(node);
01060     }
01061     public void caseATokenSet(ATokenSet node)
01062     {
01063         inATokenSet(node);
01064         if(node.getTokens() != null)
01065         {
01066             node.getTokens().apply(this);
01067         }
01068         if(node.getEq() != null)
01069         {
01070             node.getEq().apply(this);
01071         }
01072         if(node.getIdSet() != null)
01073         {
01074             node.getIdSet().apply(this);
01075         }
01076         if(node.getSemicolon() != null)
01077         {
01078             node.getSemicolon().apply(this);
01079         }
01080         outATokenSet(node);
01081     }
01082     public void caseATokenSetTokenTokenSet(ATokenSetTokenTokenSet node)
01083     {
01084         inATokenSetTokenTokenSet(node);
01085         if(node.getIdSet() != null)
01086         {
01087             node.getIdSet().apply(this);
01088         }
01089         outATokenSetTokenTokenSet(node);
01090     }
01091     public void caseATokenTokenTokenSet(ATokenTokenTokenSet node)
01092     {
01093         inATokenTokenTokenSet(node);
01094         if(node.getId() != null)
01095         {
01096             node.getId().apply(this);
01097         }
01098         outATokenTokenTokenSet(node);
01099     }
01100     public void caseAUnaryExpMultExp(AUnaryExpMultExp node)
01101     {
01102         inAUnaryExpMultExp(node);
01103         if(node.getUnaryExp() != null)
01104         {
01105             node.getUnaryExp().apply(this);
01106         }
01107         outAUnaryExpMultExp(node);
01108     }
01109     public void caseAUnaryNotPlusMinusUnaryExp(AUnaryNotPlusMinusUnaryExp node)
01110     {
01111         inAUnaryNotPlusMinusUnaryExp(node);
01112         if(node.getUnaryNotPlusMinusExp() != null)
01113         {
01114             node.getUnaryNotPlusMinusExp().apply(this);
01115         }
01116         outAUnaryNotPlusMinusUnaryExp(node);
01117     }
01118     public void caseAUnit(AUnit node)
01119     {
01120         inAUnit(node);
01121         if(node.getAbstraction() != null)
01122         {
01123             node.getAbstraction().apply(this);
01124         }
01125         if(node.getId() != null)
01126         {
01127             node.getId().apply(this);
01128         }
01129         if(node.getExtends() != null)
01130         {
01131             node.getExtends().apply(this);
01132         }
01133         if(node.getType() != null)
01134         {
01135             node.getType().apply(this);
01136         }
01137         if(node.getBegin() != null)
01138         {
01139             node.getBegin().apply(this);
01140         }
01141         if(node.getTokenSet() != null)
01142         {
01143             node.getTokenSet().apply(this);
01144         }
01145         if(node.getDefaultToken() != null)
01146         {
01147             node.getDefaultToken().apply(this);
01148         }
01149         if(node.getOne2oneSet() != null)
01150         {
01151             node.getOne2oneSet().apply(this);
01152         }
01153         if(node.getAbstractFunction() != null)
01154         {
01155             node.getAbstractFunction().apply(this);
01156         }
01157         {
01158             Object temp[] = node.getOperatorTest().toArray();
01159             for(int i = 0; i < temp.length; i++)
01160             {
01161                 ((POperatorTest) temp[i]).apply(this);
01162             }
01163         }
01164         if(node.getEnd() != null)
01165         {
01166             node.getEnd().apply(this);
01167         }
01168         outAUnit(node);
01169     }
01170     public void caseAUnsignedRightShiftExp(AUnsignedRightShiftExp node)
01171     {
01172         inAUnsignedRightShiftExp(node);
01173         if(node.getShiftExp() != null)
01174         {
01175             node.getShiftExp().apply(this);
01176         }
01177         if(node.getUnsignedShiftRight() != null)
01178         {
01179             node.getUnsignedShiftRight().apply(this);
01180         }
01181         if(node.getAddExp() != null)
01182         {
01183             node.getAddExp().apply(this);
01184         }
01185         outAUnsignedRightShiftExp(node);
01186     }
01187     public void caseAXorExclusiveOrExp(AXorExclusiveOrExp node)
01188     {
01189         inAXorExclusiveOrExp(node);
01190         if(node.getExclusiveOrExp() != null)
01191         {
01192             node.getExclusiveOrExp().apply(this);
01193         }
01194         if(node.getBitXor() != null)
01195         {
01196             node.getBitXor().apply(this);
01197         }
01198         if(node.getBitAndExp() != null)
01199         {
01200             node.getBitAndExp().apply(this);
01201         }
01202         outAXorExclusiveOrExp(node);
01203     }
01204     public void caseAXorInclusiveOrExp(AXorInclusiveOrExp node)
01205     {
01206         inAXorInclusiveOrExp(node);
01207         if(node.getExclusiveOrExp() != null)
01208         {
01209             node.getExclusiveOrExp().apply(this);
01210         }
01211         outAXorInclusiveOrExp(node);
01212     }
01213     public void caseStart(Start node)
01214     {
01215         inStart(node);
01216         node.getPUnit().apply(this);
01217         node.getEOF().apply(this);
01218         outStart(node);
01219     }
01220     public void defaultIn(Node node)
01221     {
01222     }
01223     public void defaultOut(Node node)
01224     {
01225     }
01226     public void inAAbstractFunction(AAbstractFunction node)
01227     {
01228         defaultIn(node);
01229     }
01230     public void inAAddExpShiftExp(AAddExpShiftExp node)
01231     {
01232         defaultIn(node);
01233     }
01234     public void inAAndAndExp(AAndAndExp node)
01235     {
01236         defaultIn(node);
01237     }
01238     public void inAAndBitAndExp(AAndBitAndExp node)
01239     {
01240         defaultIn(node);
01241     }
01242     public void inAAndExclusiveOrExp(AAndExclusiveOrExp node)
01243     {
01244         defaultIn(node);
01245     }
01246     public void inAAndOrExp(AAndOrExp node)
01247     {
01248         defaultIn(node);
01249     }
01250     public void inAAnyAbstractDef(AAnyAbstractDef node)
01251     {
01252         defaultIn(node);
01253     }
01254     public void inAAnyAnyId(AAnyAnyId node)
01255     {
01256         defaultIn(node);
01257     }
01258     public void inAAnyPattern(AAnyPattern node)
01259     {
01260         defaultIn(node);
01261     }
01262     public void inABitComplementUnaryNotPlusMinusExp(ABitComplementUnaryNotPlusMinusExp node)
01263     {
01264         defaultIn(node);
01265     }
01266     public void inAComplementUnaryNotPlusMinusExp(AComplementUnaryNotPlusMinusExp node)
01267     {
01268         defaultIn(node);
01269     }
01270     public void inADecIntLiteral(ADecIntLiteral node)
01271     {
01272         defaultIn(node);
01273     }
01274     public void inADecLongLiteral(ADecLongLiteral node)
01275     {
01276         defaultIn(node);
01277     }
01278     public void inADefaultToken(ADefaultToken node)
01279     {
01280         defaultIn(node);
01281     }
01282     public void inADivMultExp(ADivMultExp node)
01283     {
01284         defaultIn(node);
01285     }
01286     public void inADivOp(ADivOp node)
01287     {
01288         defaultIn(node);
01289     }
01290     public void inADoubleLiteral(ADoubleLiteral node)
01291     {
01292         defaultIn(node);
01293     }
01294     public void inAEqBitAndExp(AEqBitAndExp node)
01295     {
01296         defaultIn(node);
01297     }
01298     public void inAEqEqExp(AEqEqExp node)
01299     {
01300         defaultIn(node);
01301     }
01302     public void inAEqualTOp(AEqualTOp node)
01303     {
01304         defaultIn(node);
01305     }
01306     public void inAExp(AExp node)
01307     {
01308         defaultIn(node);
01309     }
01310     public void inAExpAbstractDef(AExpAbstractDef node)
01311     {
01312         defaultIn(node);
01313     }
01314     public void inAFloatLiteral(AFloatLiteral node)
01315     {
01316         defaultIn(node);
01317     }
01318     public void inAGreaterEqualRelExp(AGreaterEqualRelExp node)
01319     {
01320         defaultIn(node);
01321     }
01322     public void inAGreaterEqualTOp(AGreaterEqualTOp node)
01323     {
01324         defaultIn(node);
01325     }
01326     public void inAGreaterRelExp(AGreaterRelExp node)
01327     {
01328         defaultIn(node);
01329     }
01330     public void inAGreaterTOp(AGreaterTOp node)
01331     {
01332         defaultIn(node);
01333     }
01334     public void inAHexIntLiteral(AHexIntLiteral node)
01335     {
01336         defaultIn(node);
01337     }
01338     public void inAHexLongLiteral(AHexLongLiteral node)
01339     {
01340         defaultIn(node);
01341     }
01342     public void inAIdAnyId(AIdAnyId node)
01343     {
01344         defaultIn(node);
01345     }
01346     public void inAIdIdList(AIdIdList node)
01347     {
01348         defaultIn(node);
01349     }
01350     public void inAIdPrimaryExp(AIdPrimaryExp node)
01351     {
01352         defaultIn(node);
01353     }
01354     public void inAIdSet(AIdSet node)
01355     {
01356         defaultIn(node);
01357     }
01358     public void inAIdsIdList(AIdsIdList node)
01359     {
01360         defaultIn(node);
01361     }
01362     public void inAInclusiveOrAndExp(AInclusiveOrAndExp node)
01363     {
01364         defaultIn(node);
01365     }
01366     public void inAIntegralType(AIntegralType node)
01367     {
01368         defaultIn(node);
01369     }
01370     public void inALeftShiftExp(ALeftShiftExp node)
01371     {
01372         defaultIn(node);
01373     }
01374     public void inALessEqualRelExp(ALessEqualRelExp node)
01375     {
01376         defaultIn(node);
01377     }
01378     public void inALessEqualTOp(ALessEqualTOp node)
01379     {
01380         defaultIn(node);
01381     }
01382     public void inALessRelExp(ALessRelExp node)
01383     {
01384         defaultIn(node);
01385     }
01386     public void inALessTOp(ALessTOp node)
01387     {
01388         defaultIn(node);
01389     }
01390     public void inALiteralPrimaryExp(ALiteralPrimaryExp node)
01391     {
01392         defaultIn(node);
01393     }
01394     public void inAMinusAddExp(AMinusAddExp node)
01395     {
01396         defaultIn(node);
01397     }
01398     public void inAMinusOp(AMinusOp node)
01399     {
01400         defaultIn(node);
01401     }
01402     public void inAMinusUnaryExp(AMinusUnaryExp node)
01403     {
01404         defaultIn(node);
01405     }
01406     public void inAModMultExp(AModMultExp node)
01407     {
01408         defaultIn(node);
01409     }
01410     public void inAModOp(AModOp node)
01411     {
01412         defaultIn(node);
01413     }
01414     public void inAMultAddExp(AMultAddExp node)
01415     {
01416         defaultIn(node);
01417     }
01418     public void inANeqEqExp(ANeqEqExp node)
01419     {
01420         defaultIn(node);
01421     }
01422     public void inANotEqualTOp(ANotEqualTOp node)
01423     {
01424         defaultIn(node);
01425     }
01426     public void inAOctIntLiteral(AOctIntLiteral node)
01427     {
01428         defaultIn(node);
01429     }
01430     public void inAOctLongLiteral(AOctLongLiteral node)
01431     {
01432         defaultIn(node);
01433     }
01434     public void inAOne2oneSet(AOne2oneSet node)
01435     {
01436         defaultIn(node);
01437     }
01438     public void inAOperator(AOperator node)
01439     {
01440         defaultIn(node);
01441     }
01442     public void inAOperatorOperatorTest(AOperatorOperatorTest node)
01443     {
01444         defaultIn(node);
01445     }
01446     public void inAOrConditionalExp(AOrConditionalExp node)
01447     {
01448         defaultIn(node);
01449     }
01450     public void inAOrInclusiveOrExp(AOrInclusiveOrExp node)
01451     {
01452         defaultIn(node);
01453     }
01454     public void inAOrOrExp(AOrOrExp node)
01455     {
01456         defaultIn(node);
01457     }
01458     public void inAParenPrimaryExp(AParenPrimaryExp node)
01459     {
01460         defaultIn(node);
01461     }
01462     public void inAPatternPattern(APatternPattern node)
01463     {
01464         defaultIn(node);
01465     }
01466     public void inAPlusAddExp(APlusAddExp node)
01467     {
01468         defaultIn(node);
01469     }
01470     public void inAPlusOp(APlusOp node)
01471     {
01472         defaultIn(node);
01473     }
01474     public void inAPlusUnaryExp(APlusUnaryExp node)
01475     {
01476         defaultIn(node);
01477     }
01478     public void inAPrimaryUnaryNotPlusMinusExp(APrimaryUnaryNotPlusMinusExp node)
01479     {
01480         defaultIn(node);
01481     }
01482     public void inAQuestionConditionalExp(AQuestionConditionalExp node)
01483     {
01484         defaultIn(node);
01485     }
01486     public void inARealType(ARealType node)
01487     {
01488         defaultIn(node);
01489     }
01490     public void inARelEqExp(ARelEqExp node)
01491     {
01492         defaultIn(node);
01493     }
01494     public void inAShiftRelExp(AShiftRelExp node)
01495     {
01496         defaultIn(node);
01497     }
01498     public void inASignedRightShiftExp(ASignedRightShiftExp node)
01499     {
01500         defaultIn(node);
01501     }
01502     public void inATest(ATest node)
01503     {
01504         defaultIn(node);
01505     }
01506     public void inATestOperatorTest(ATestOperatorTest node)
01507     {
01508         defaultIn(node);
01509     }
01510     public void inATimesMultExp(ATimesMultExp node)
01511     {
01512         defaultIn(node);
01513     }
01514     public void inATimesOp(ATimesOp node)
01515     {
01516         defaultIn(node);
01517     }
01518     public void inATokenSet(ATokenSet node)
01519     {
01520         defaultIn(node);
01521     }
01522     public void inATokenSetTokenTokenSet(ATokenSetTokenTokenSet node)
01523     {
01524         defaultIn(node);
01525     }
01526     public void inATokenTokenTokenSet(ATokenTokenTokenSet node)
01527     {
01528         defaultIn(node);
01529     }
01530     public void inAUnaryExpMultExp(AUnaryExpMultExp node)
01531     {
01532         defaultIn(node);
01533     }
01534     public void inAUnaryNotPlusMinusUnaryExp(AUnaryNotPlusMinusUnaryExp node)
01535     {
01536         defaultIn(node);
01537     }
01538     public void inAUnit(AUnit node)
01539     {
01540         defaultIn(node);
01541     }
01542     public void inAUnsignedRightShiftExp(AUnsignedRightShiftExp node)
01543     {
01544         defaultIn(node);
01545     }
01546     public void inAXorExclusiveOrExp(AXorExclusiveOrExp node)
01547     {
01548         defaultIn(node);
01549     }
01550     public void inAXorInclusiveOrExp(AXorInclusiveOrExp node)
01551     {
01552         defaultIn(node);
01553     }
01554     public void inStart(Start node)
01555     {
01556         defaultIn(node);
01557     }
01558     public void outAAbstractFunction(AAbstractFunction node)
01559     {
01560         defaultOut(node);
01561     }
01562     public void outAAddExpShiftExp(AAddExpShiftExp node)
01563     {
01564         defaultOut(node);
01565     }
01566     public void outAAndAndExp(AAndAndExp node)
01567     {
01568         defaultOut(node);
01569     }
01570     public void outAAndBitAndExp(AAndBitAndExp node)
01571     {
01572         defaultOut(node);
01573     }
01574     public void outAAndExclusiveOrExp(AAndExclusiveOrExp node)
01575     {
01576         defaultOut(node);
01577     }
01578     public void outAAndOrExp(AAndOrExp node)
01579     {
01580         defaultOut(node);
01581     }
01582     public void outAAnyAbstractDef(AAnyAbstractDef node)
01583     {
01584         defaultOut(node);
01585     }
01586     public void outAAnyAnyId(AAnyAnyId node)
01587     {
01588         defaultOut(node);
01589     }
01590     public void outAAnyPattern(AAnyPattern node)
01591     {
01592         defaultOut(node);
01593     }
01594     public void outABitComplementUnaryNotPlusMinusExp(ABitComplementUnaryNotPlusMinusExp node)
01595     {
01596         defaultOut(node);
01597     }
01598     public void outAComplementUnaryNotPlusMinusExp(AComplementUnaryNotPlusMinusExp node)
01599     {
01600         defaultOut(node);
01601     }
01602     public void outADecIntLiteral(ADecIntLiteral node)
01603     {
01604         defaultOut(node);
01605     }
01606     public void outADecLongLiteral(ADecLongLiteral node)
01607     {
01608         defaultOut(node);
01609     }
01610     public void outADefaultToken(ADefaultToken node)
01611     {
01612         defaultOut(node);
01613     }
01614     public void outADivMultExp(ADivMultExp node)
01615     {
01616         defaultOut(node);
01617     }
01618     public void outADivOp(ADivOp node)
01619     {
01620         defaultOut(node);
01621     }
01622     public void outADoubleLiteral(ADoubleLiteral node)
01623     {
01624         defaultOut(node);
01625     }
01626     public void outAEqBitAndExp(AEqBitAndExp node)
01627     {
01628         defaultOut(node);
01629     }
01630     public void outAEqEqExp(AEqEqExp node)
01631     {
01632         defaultOut(node);
01633     }
01634     public void outAEqualTOp(AEqualTOp node)
01635     {
01636         defaultOut(node);
01637     }
01638     public void outAExp(AExp node)
01639     {
01640         defaultOut(node);
01641     }
01642     public void outAExpAbstractDef(AExpAbstractDef node)
01643     {
01644         defaultOut(node);
01645     }
01646     public void outAFloatLiteral(AFloatLiteral node)
01647     {
01648         defaultOut(node);
01649     }
01650     public void outAGreaterEqualRelExp(AGreaterEqualRelExp node)
01651     {
01652         defaultOut(node);
01653     }
01654     public void outAGreaterEqualTOp(AGreaterEqualTOp node)
01655     {
01656         defaultOut(node);
01657     }
01658     public void outAGreaterRelExp(AGreaterRelExp node)
01659     {
01660         defaultOut(node);
01661     }
01662     public void outAGreaterTOp(AGreaterTOp node)
01663     {
01664         defaultOut(node);
01665     }
01666     public void outAHexIntLiteral(AHexIntLiteral node)
01667     {
01668         defaultOut(node);
01669     }
01670     public void outAHexLongLiteral(AHexLongLiteral node)
01671     {
01672         defaultOut(node);
01673     }
01674     public void outAIdAnyId(AIdAnyId node)
01675     {
01676         defaultOut(node);
01677     }
01678     public void outAIdIdList(AIdIdList node)
01679     {
01680         defaultOut(node);
01681     }
01682     public void outAIdPrimaryExp(AIdPrimaryExp node)
01683     {
01684         defaultOut(node);
01685     }
01686     public void outAIdSet(AIdSet node)
01687     {
01688         defaultOut(node);
01689     }
01690     public void outAIdsIdList(AIdsIdList node)
01691     {
01692         defaultOut(node);
01693     }
01694     public void outAInclusiveOrAndExp(AInclusiveOrAndExp node)
01695     {
01696         defaultOut(node);
01697     }
01698     public void outAIntegralType(AIntegralType node)
01699     {
01700         defaultOut(node);
01701     }
01702     public void outALeftShiftExp(ALeftShiftExp node)
01703     {
01704         defaultOut(node);
01705     }
01706     public void outALessEqualRelExp(ALessEqualRelExp node)
01707     {
01708         defaultOut(node);
01709     }
01710     public void outALessEqualTOp(ALessEqualTOp node)
01711     {
01712         defaultOut(node);
01713     }
01714     public void outALessRelExp(ALessRelExp node)
01715     {
01716         defaultOut(node);
01717     }
01718     public void outALessTOp(ALessTOp node)
01719     {
01720         defaultOut(node);
01721     }
01722     public void outALiteralPrimaryExp(ALiteralPrimaryExp node)
01723     {
01724         defaultOut(node);
01725     }
01726     public void outAMinusAddExp(AMinusAddExp node)
01727     {
01728         defaultOut(node);
01729     }
01730     public void outAMinusOp(AMinusOp node)
01731     {
01732         defaultOut(node);
01733     }
01734     public void outAMinusUnaryExp(AMinusUnaryExp node)
01735     {
01736         defaultOut(node);
01737     }
01738     public void outAModMultExp(AModMultExp node)
01739     {
01740         defaultOut(node);
01741     }
01742     public void outAModOp(AModOp node)
01743     {
01744         defaultOut(node);
01745     }
01746     public void outAMultAddExp(AMultAddExp node)
01747     {
01748         defaultOut(node);
01749     }
01750     public void outANeqEqExp(ANeqEqExp node)
01751     {
01752         defaultOut(node);
01753     }
01754     public void outANotEqualTOp(ANotEqualTOp node)
01755     {
01756         defaultOut(node);
01757     }
01758     public void outAOctIntLiteral(AOctIntLiteral node)
01759     {
01760         defaultOut(node);
01761     }
01762     public void outAOctLongLiteral(AOctLongLiteral node)
01763     {
01764         defaultOut(node);
01765     }
01766     public void outAOne2oneSet(AOne2oneSet node)
01767     {
01768         defaultOut(node);
01769     }
01770     public void outAOperator(AOperator node)
01771     {
01772         defaultOut(node);
01773     }
01774     public void outAOperatorOperatorTest(AOperatorOperatorTest node)
01775     {
01776         defaultOut(node);
01777     }
01778     public void outAOrConditionalExp(AOrConditionalExp node)
01779     {
01780         defaultOut(node);
01781     }
01782     public void outAOrInclusiveOrExp(AOrInclusiveOrExp node)
01783     {
01784         defaultOut(node);
01785     }
01786     public void outAOrOrExp(AOrOrExp node)
01787     {
01788         defaultOut(node);
01789     }
01790     public void outAParenPrimaryExp(AParenPrimaryExp node)
01791     {
01792         defaultOut(node);
01793     }
01794     public void outAPatternPattern(APatternPattern node)
01795     {
01796         defaultOut(node);
01797     }
01798     public void outAPlusAddExp(APlusAddExp node)
01799     {
01800         defaultOut(node);
01801     }
01802     public void outAPlusOp(APlusOp node)
01803     {
01804         defaultOut(node);
01805     }
01806     public void outAPlusUnaryExp(APlusUnaryExp node)
01807     {
01808         defaultOut(node);
01809     }
01810     public void outAPrimaryUnaryNotPlusMinusExp(APrimaryUnaryNotPlusMinusExp node)
01811     {
01812         defaultOut(node);
01813     }
01814     public void outAQuestionConditionalExp(AQuestionConditionalExp node)
01815     {
01816         defaultOut(node);
01817     }
01818     public void outARealType(ARealType node)
01819     {
01820         defaultOut(node);
01821     }
01822     public void outARelEqExp(ARelEqExp node)
01823     {
01824         defaultOut(node);
01825     }
01826     public void outAShiftRelExp(AShiftRelExp node)
01827     {
01828         defaultOut(node);
01829     }
01830     public void outASignedRightShiftExp(ASignedRightShiftExp node)
01831     {
01832         defaultOut(node);
01833     }
01834     public void outATest(ATest node)
01835     {
01836         defaultOut(node);
01837     }
01838     public void outATestOperatorTest(ATestOperatorTest node)
01839     {
01840         defaultOut(node);
01841     }
01842     public void outATimesMultExp(ATimesMultExp node)
01843     {
01844         defaultOut(node);
01845     }
01846     public void outATimesOp(ATimesOp node)
01847     {
01848         defaultOut(node);
01849     }
01850     public void outATokenSet(ATokenSet node)
01851     {
01852         defaultOut(node);
01853     }
01854     public void outATokenSetTokenTokenSet(ATokenSetTokenTokenSet node)
01855     {
01856         defaultOut(node);
01857     }
01858     public void outATokenTokenTokenSet(ATokenTokenTokenSet node)
01859     {
01860         defaultOut(node);
01861     }
01862     public void outAUnaryExpMultExp(AUnaryExpMultExp node)
01863     {
01864         defaultOut(node);
01865     }
01866     public void outAUnaryNotPlusMinusUnaryExp(AUnaryNotPlusMinusUnaryExp node)
01867     {
01868         defaultOut(node);
01869     }
01870     public void outAUnit(AUnit node)
01871     {
01872         defaultOut(node);
01873     }
01874     public void outAUnsignedRightShiftExp(AUnsignedRightShiftExp node)
01875     {
01876         defaultOut(node);
01877     }
01878     public void outAXorExclusiveOrExp(AXorExclusiveOrExp node)
01879     {
01880         defaultOut(node);
01881     }
01882     public void outAXorInclusiveOrExp(AXorInclusiveOrExp node)
01883     {
01884         defaultOut(node);
01885     }
01886     public void outStart(Start node)
01887     {
01888         defaultOut(node);
01889     }
01890 }